{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "sys.path.append('/home/yang_liu/python_workspace/3DGS')\n",
    "\n",
    "import yaml\n",
    "import torch\n",
    "import torchvision\n",
    "import torch_scatter\n",
    "import wandb\n",
    "import time\n",
    "import inspect\n",
    "import imageio\n",
    "import numpy as np\n",
    "import open3d as o3d\n",
    "import pynvml\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from arguments import GroupParams\n",
    "from scene import LargeScene\n",
    "from os import makedirs\n",
    "from gaussian_renderer import render_lod, render\n",
    "from utils.general_utils import safe_state\n",
    "from utils.large_utils import which_block, block_filtering\n",
    "from utils.sh_utils import SH2RGB\n",
    "from argparse import ArgumentParser\n",
    "from arguments import ModelParams, PipelineParams, get_combined_args\n",
    "from gaussian_renderer import GaussianModel\n",
    "from torch.utils.data import DataLoader\n",
    "from utils.camera_utils import loadCamV2\n",
    "from transforms3d.euler import mat2euler, euler2mat\n",
    "from transforms3d.quaternions import mat2quat, quat2mat\n",
    "from utils.general_utils import PILtoTorch\n",
    "from scene.cameras import Camera\n",
    "from scipy.spatial import ConvexHull\n",
    "from matplotlib.backends.backend_agg import FigureCanvasAgg\n",
    "\n",
    "WARNED = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BlockedGaussian:\n",
    "\n",
    "    gaussians : GaussianModel\n",
    "\n",
    "    def __init__(self, gaussians, lp, range=[0, 1], scale=1.0, compute_cov3D_python=False):\n",
    "        self.cell_corners = []\n",
    "        self.xyz = None\n",
    "        self.feats = None\n",
    "        self.max_sh_degree = lp.sh_degree\n",
    "        self.device = gaussians.get_xyz.device\n",
    "        self.compute_cov3D_python = compute_cov3D_python\n",
    "        self.cell_ids = torch.zeros(gaussians.get_opacity.shape[0], dtype=torch.long, device=self.device)\n",
    "        self.mask = torch.zeros(gaussians.get_opacity.shape[0], dtype=torch.bool, device=self.device)\n",
    "\n",
    "        self.block_dim = lp.block_dim\n",
    "        self.num_cell = lp.block_dim[0] * lp.block_dim[1] * lp.block_dim[2]\n",
    "        self.aabb = lp.aabb\n",
    "        self.scale = scale\n",
    "        self.range = range\n",
    "\n",
    "        self.cell_divider(gaussians)\n",
    "        self.cell_corners = torch.stack(self.cell_corners, dim=0)\n",
    "\n",
    "    def cell_divider(self, gaussians, n=4):\n",
    "        with torch.no_grad():\n",
    "            if self.compute_cov3D_python:\n",
    "                geometry = gaussians.get_covariance(self.scale).to(self.device)\n",
    "            else:\n",
    "                geometry = torch.cat([gaussians.get_scaling,\n",
    "                                      gaussians.get_rotation], dim=1)\n",
    "            self.xyz = gaussians.get_xyz\n",
    "            self.feats = torch.cat([gaussians.get_opacity,  \n",
    "                                    gaussians.get_features.reshape(geometry.shape[0], -1),\n",
    "                                    geometry], dim=1).half()\n",
    "            \n",
    "            for cell_idx in range(self.num_cell):\n",
    "                cell_mask = block_filtering(cell_idx, self.xyz, self.aabb, self.block_dim, self.scale)\n",
    "                self.cell_ids[cell_mask] = cell_idx\n",
    "                # MAD to eliminate influence of outsiders\n",
    "                xyz_median = torch.median(self.xyz[cell_mask], dim=0)[0]\n",
    "                delta_median = torch.median(torch.abs(self.xyz[cell_mask] - xyz_median), dim=0)[0]\n",
    "                xyz_min = xyz_median - n * delta_median\n",
    "                xyz_min = torch.max(xyz_min, torch.min(self.xyz[cell_mask], dim=0)[0])\n",
    "                xyz_max = xyz_median + n * delta_median\n",
    "                xyz_max = torch.min(xyz_max, torch.max(self.xyz[cell_mask], dim=0)[0])\n",
    "                corners = torch.tensor([[xyz_min[0], xyz_min[1], xyz_min[2]],\n",
    "                                       [xyz_min[0], xyz_min[1], xyz_max[2]],\n",
    "                                       [xyz_min[0], xyz_max[1], xyz_min[2]],\n",
    "                                       [xyz_min[0], xyz_max[1], xyz_max[2]],\n",
    "                                       [xyz_max[0], xyz_min[1], xyz_min[2]],\n",
    "                                       [xyz_max[0], xyz_min[1], xyz_max[2]],\n",
    "                                       [xyz_max[0], xyz_max[1], xyz_min[2]],\n",
    "                                       [xyz_max[0], xyz_max[1], xyz_max[2]]], device=self.xyz.device)\n",
    "                self.cell_corners.append(corners)\n",
    "    \n",
    "    def get_feats(self, indices, distances):\n",
    "        out_xyz = torch.tensor([], device=self.device, dtype=self.xyz.dtype)\n",
    "        out_feats = torch.tensor([], device=self.device, dtype=self.feats.dtype)\n",
    "        block_mask = (distances >= self.range[0]) & (distances < self.range[1])\n",
    "        if block_mask.sum() > 0:\n",
    "            self.mask = torch.isin(self.cell_ids, indices[block_mask].to(self.device))\n",
    "            out_xyz = self.xyz[self.mask]\n",
    "            out_feats = self.feats[self.mask]\n",
    "        return out_xyz, out_feats\n",
    "\n",
    "    def get_feats_ptwise(self, viewpoint_cam):\n",
    "        out_xyz = torch.tensor([], device=self.device, dtype=self.xyz.dtype)\n",
    "        out_feats = torch.tensor([], device=self.device, dtype=self.feats.dtype)\n",
    "\n",
    "        homo_xyz = torch.cat([self.xyz, torch.ones_like(self.xyz[..., [0]])], dim=-1)\n",
    "        cam_center = viewpoint_cam.camera_center\n",
    "        viewmatrix = viewpoint_cam.world_view_transform\n",
    "        xyz_cam = homo_xyz @ viewmatrix\n",
    "        self.mask = (xyz_cam[..., 2] > 0.2)\n",
    "        if self.mask.sum() == 0:\n",
    "            return out_xyz, out_feats\n",
    "\n",
    "        distances = torch.norm(self.xyz - cam_center[None, :3], dim=-1)\n",
    "        self.mask &= (distances >= self.range[0]) & (distances < self.range[1])\n",
    "        if self.mask.sum() > 0:\n",
    "            out_xyz = self.xyz[self.mask]\n",
    "            out_feats = self.feats[self.mask]\n",
    "        return out_xyz, out_feats\n",
    "\n",
    "def load_gaussians(cfg, config_name, iteration=30_000, load_vq=False, device='cuda', source_path='data/matrix_city/aerial/test/block_all_test'):\n",
    "    \n",
    "    lp, op, pp = parse_cfg(cfg)\n",
    "    setattr(lp, 'config_path', cfg)\n",
    "    lp.source_path = source_path\n",
    "    lp.model_path = os.path.join(\"../output/\", config_name)\n",
    "\n",
    "    modules = __import__('scene')\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        if 'apply_voxelize' in lp.model_config['kwargs'].keys():\n",
    "            lp.model_config['kwargs']['apply_voxelize'] = False\n",
    "        gaussians = getattr(modules, lp.model_config['name'])(lp.sh_degree, device=device, **lp.model_config['kwargs'])\n",
    "        scene = LargeScene(lp, gaussians, load_iteration=iteration, load_vq=load_vq, shuffle=False)\n",
    "        print(f'Init {config_name} with {len(gaussians.get_opacity)} points\\n')\n",
    "\n",
    "    return gaussians, scene\n",
    "\n",
    "def parse_cfg(cfg):\n",
    "    lp = GroupParams()\n",
    "    op = GroupParams()\n",
    "    pp = GroupParams()\n",
    "\n",
    "    for arg in cfg['model_params'].items():\n",
    "        setattr(lp, arg[0], arg[1])\n",
    "    \n",
    "    for arg in cfg['optim_params'].items():\n",
    "        setattr(op, arg[0], arg[1]) \n",
    "\n",
    "    for arg in cfg['pipeline_params'].items():\n",
    "        setattr(pp, arg[0], arg[1])\n",
    "    \n",
    "    return lp, op, pp\n",
    "\n",
    "def loadCamV3(args, id, cam_info, resolution_scale, xyz=None, z_dim=None, yaw=None):\n",
    "    # use appointed pitch and height\n",
    "    orig_w, orig_h = cam_info.image.size\n",
    "\n",
    "    if args.resolution in [1, 2, 4, 8]:\n",
    "        resolution = round(orig_w/(resolution_scale * args.resolution)), round(orig_h/(resolution_scale * args.resolution))\n",
    "    else:  # should be a type that converts to float\n",
    "        if args.resolution == -1:\n",
    "            if orig_w > 1600:\n",
    "                global WARNED\n",
    "                if not WARNED:\n",
    "                    print(\"[ INFO ] Encountered quite large input images (>1.6K pixels width), rescaling to 1.6K.\\n \"\n",
    "                        \"If this is not desired, please explicitly specify '--resolution/-r' as 1\")\n",
    "                    WARNED = True\n",
    "                global_down = orig_w / 1600\n",
    "            else:\n",
    "                global_down = 1\n",
    "        else:\n",
    "            global_down = orig_w / args.resolution\n",
    "\n",
    "        scale = float(global_down) * float(resolution_scale)\n",
    "        resolution = (int(orig_w / scale), int(orig_h / scale))\n",
    "\n",
    "    resized_image_rgb = PILtoTorch(cam_info.image, resolution)\n",
    "\n",
    "    gt_image = resized_image_rgb[:3, ...]\n",
    "    loaded_mask = None\n",
    "\n",
    "    if resized_image_rgb.shape[1] == 4:\n",
    "        loaded_mask = resized_image_rgb[3:4, ...]\n",
    "\n",
    "    if yaw is not None and z_dim is not None and xyz is not None:\n",
    "        Rt = np.zeros((4, 4))\n",
    "        Rt[:3, :3] = cam_info.R.transpose()\n",
    "        Rt[:3, 3] = cam_info.T\n",
    "        Rt[3, 3] = 1.0\n",
    "\n",
    "        C2W = np.linalg.inv(Rt)\n",
    "        euler = np.array(mat2euler(C2W[:3, :3]))\n",
    "        euler[z_dim] = yaw\n",
    "        C2W[:3, :3] = euler2mat(*euler)\n",
    "        C2W[:3, 3] = xyz\n",
    "        Rt = np.linalg.inv(C2W)\n",
    "\n",
    "        R = Rt[:3, :3].transpose()\n",
    "        T = Rt[:3, 3]\n",
    "    else:\n",
    "        R = cam_info.R\n",
    "        T = cam_info.T\n",
    "\n",
    "    return Camera(colmap_id=cam_info.uid, R=R, T=T, \n",
    "                  FoVx=cam_info.FovX, FoVy=cam_info.FovY, \n",
    "                  image=gt_image, gt_alpha_mask=loaded_mask,\n",
    "                  image_name=cam_info.image_name, uid=id, data_device=args.data_device)\n",
    "\n",
    "def loadCamV4(args, id, cam_info, resolution_scale, xyz=None, angle=None):\n",
    "    # use appointed pitch and height\n",
    "    orig_w, orig_h = cam_info.image.size\n",
    "\n",
    "    if args.resolution in [1, 2, 4, 8]:\n",
    "        resolution = round(orig_w/(resolution_scale * args.resolution)), round(orig_h/(resolution_scale * args.resolution))\n",
    "    else:  # should be a type that converts to float\n",
    "        if args.resolution == -1:\n",
    "            if orig_w > 1600:\n",
    "                global WARNED\n",
    "                if not WARNED:\n",
    "                    print(\"[ INFO ] Encountered quite large input images (>1.6K pixels width), rescaling to 1.6K.\\n \"\n",
    "                        \"If this is not desired, please explicitly specify '--resolution/-r' as 1\")\n",
    "                    WARNED = True\n",
    "                global_down = orig_w / 1600\n",
    "            else:\n",
    "                global_down = 1\n",
    "        else:\n",
    "            global_down = orig_w / args.resolution\n",
    "\n",
    "        scale = float(global_down) * float(resolution_scale)\n",
    "        resolution = (int(orig_w / scale), int(orig_h / scale))\n",
    "\n",
    "    resized_image_rgb = PILtoTorch(cam_info.image, resolution)\n",
    "\n",
    "    gt_image = resized_image_rgb[:3, ...]\n",
    "    loaded_mask = None\n",
    "\n",
    "    if resized_image_rgb.shape[1] == 4:\n",
    "        loaded_mask = resized_image_rgb[3:4, ...]\n",
    "\n",
    "    if angle is not None and xyz is not None:\n",
    "        Rt = np.zeros((4, 4))\n",
    "        Rt[:3, :3] = cam_info.R.transpose()\n",
    "        Rt[:3, 3] = cam_info.T\n",
    "        Rt[3, 3] = 1.0\n",
    "\n",
    "        C2W = np.linalg.inv(Rt)\n",
    "        euler = np.array(mat2euler(C2W[:3, :3]))\n",
    "        euler = angle\n",
    "        C2W[:3, :3] = euler2mat(*euler)\n",
    "        C2W[:3, 3] = xyz\n",
    "        Rt = np.linalg.inv(C2W)\n",
    "\n",
    "        R = Rt[:3, :3].transpose()\n",
    "        T = Rt[:3, 3]\n",
    "    else:\n",
    "        R = cam_info.R\n",
    "        T = cam_info.T\n",
    "\n",
    "    return Camera(colmap_id=cam_info.uid, R=R, T=T, \n",
    "                  FoVx=cam_info.FovX, FoVy=cam_info.FovY, \n",
    "                  image=gt_image, gt_alpha_mask=loaded_mask,\n",
    "                  image_name=cam_info.image_name, uid=id, data_device=args.data_device)\n",
    "\n",
    "# find the a & b points\n",
    "def get_bezier_coef(points):\n",
    "    # since the formulas work given that we have n+1 points\n",
    "    # then n must be this:\n",
    "    n = len(points) - 1\n",
    "\n",
    "    # build coefficents matrix\n",
    "    C = 4 * np.identity(n)\n",
    "    np.fill_diagonal(C[1:], 1)\n",
    "    np.fill_diagonal(C[:, 1:], 1)\n",
    "    C[0, 0] = 2\n",
    "    C[n - 1, n - 1] = 7\n",
    "    C[n - 1, n - 2] = 2\n",
    "\n",
    "    # build points vector\n",
    "    P = [2 * (2 * points[i] + points[i + 1]) for i in range(n)]\n",
    "    P[0] = points[0] + 2 * points[1]\n",
    "    P[n - 1] = 8 * points[n - 1] + points[n]\n",
    "\n",
    "    # solve system, find a & b\n",
    "    A = np.linalg.solve(C, P)\n",
    "    B = [0] * n\n",
    "    for i in range(n - 1):\n",
    "        B[i] = 2 * points[i + 1] - A[i + 1]\n",
    "    B[n - 1] = (A[n - 1] + points[n]) / 2\n",
    "\n",
    "    return A, B\n",
    "\n",
    "# returns the general Bezier cubic formula given 4 control points\n",
    "def get_cubic(a, b, c, d):\n",
    "    return lambda t: np.power(1 - t, 3) * a + 3 * np.power(1 - t, 2) * t * b + 3 * (1 - t) * np.power(t, 2) * c + np.power(t, 3) * d\n",
    "\n",
    "# return one cubic curve for each consecutive points\n",
    "def get_bezier_cubic(points):\n",
    "    A, B = get_bezier_coef(points)\n",
    "    return [\n",
    "        get_cubic(points[i], A[i], B[i], points[i + 1])\n",
    "        for i in range(len(points) - 1)\n",
    "    ]\n",
    "\n",
    "# evalute each cubic curve on the range [0, 1] sliced in n points\n",
    "def evaluate_bezier(points, n):\n",
    "    curves = get_bezier_cubic(points)\n",
    "    seg_length = [np.linalg.norm(points[i] - points[i + 1]) for i in range(len(points) - 1)]\n",
    "    mean_length = np.mean(np.array(seg_length))\n",
    "    return np.array([fun(t) for length, fun in zip(seg_length, curves) for t in np.linspace(0, 1, max(int(n * length / mean_length), 1))])\n",
    "\n",
    "def evaluate_bezier_v2(points, n):\n",
    "    curves = get_bezier_cubic(points)\n",
    "    seg_length = [np.linalg.norm(points[i] - points[i + 1]) for i in range(len(points) - 1)]\n",
    "    mean_length = np.mean(np.array(seg_length))\n",
    "    seg_pts_num = np.array([max(int(n * length / mean_length), 1) for length in seg_length])\n",
    "    acc_pts_num = np.cumsum(seg_pts_num)\n",
    "    pts = np.array([fun(t) for length, fun in zip(seg_length, curves) for t in np.linspace(0, 1, max(int(n * length / mean_length), 1))])\n",
    "    return pts, acc_pts_num\n",
    "\n",
    "def evaluate_bezier_v3(points, n):\n",
    "    curves = get_bezier_cubic(points)\n",
    "    seg_samples = [n]\n",
    "    speed_start = None\n",
    "    speed_end_pre = curves[0](1) - curves[0](1-1/n)\n",
    "    for idx in range(1, len(curves)):\n",
    "        speed_start = curves[idx](1/n) - curves[idx](0)\n",
    "        n = int(n * np.linalg.norm(speed_start) / np.linalg.norm(speed_end_pre))\n",
    "        seg_samples.append(n)\n",
    "        speed_end_pre = curves[idx](1) - curves[idx](1-1/n)\n",
    "        \n",
    "    acc_pts_num = np.cumsum(np.array(seg_samples))\n",
    "    pts = np.array([fun(t) for samples, fun in zip(seg_samples, curves) for t in np.linspace(0, 1, max(samples, 1))])\n",
    "    return pts, acc_pts_num\n",
    "\n",
    "def np_move_avg(a,n,mode=\"same\"):\n",
    "    b = a.copy()\n",
    "    b[n//2:-n//2] = np.convolve(a, np.ones((n,))/n, mode=mode)[n//2:-n//2]\n",
    "    return b\n",
    "\n",
    "def np_move_avg_v2(a,n,mode=\"same\"):\n",
    "    b = a.copy()\n",
    "    if len(b.shape) == 1:\n",
    "        b[n//2:-n//2] = np.convolve(a, np.ones((n,))/n, mode=mode)[n//2:-n//2]\n",
    "    else:\n",
    "        for i in range(b.shape[1]):\n",
    "            b[n//2:-n//2, i] = np.convolve(a[:, i], np.ones((n,))/n, mode=mode)[n//2:-n//2]\n",
    "    return b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Render from training view"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Use LoD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading camera 1657/1657\n",
      "Init block_rubble_all_lr_c9_loss_12_r4_40_lr64_vq with 5844738 points\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/yang_liu/python_workspace/3DGS/utils/large_utils.py:38: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  xyz_tensor = torch.tensor(xyz_org)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading camera 1657/1657\n",
      "Init block_rubble_all_lr_c9_loss_12_r4_50_lr64_vq with 4870615 points\n",
      "\n",
      "Reading camera 1657/1657\n",
      "Init block_rubble_all_lr_c9_loss_12_r4_60_lr64_vq with 3896492 points\n",
      "\n"
     ]
    }
   ],
   "source": [
    "load_vq = True\n",
    "iteration = 30_000\n",
    "custom_test = '../data/mill19/rubble-pixsfm/train'\n",
    "if load_vq:\n",
    "    iteration = None\n",
    "\n",
    "config = \"../config/block_rubble_all_lr_c9_loss_12_r4_lod.yaml\"\n",
    "model_path = os.path.join('../output', os.path.basename(config).split('.')[0])\n",
    "with open(config) as f:\n",
    "    cfg = yaml.load(f, Loader=yaml.FullLoader)\n",
    "    lp, op, pp = parse_cfg(cfg)\n",
    "    setattr(lp, 'config_path', config)\n",
    "    if lp.model_path == '':\n",
    "        lp.model_path = model_path\n",
    "\n",
    "assert len(lp.lod_configs)-1 == len(lp.dist_threshold)\n",
    "lp.dist_threshold = [0] + lp.dist_threshold + [1e6]\n",
    "\n",
    "with torch.no_grad():\n",
    "    lod_gs_list = []\n",
    "    for i in range(len(lp.lod_configs)):\n",
    "        config = os.path.join(\"..\", lp.lod_configs[i])\n",
    "        config_name = os.path.splitext(os.path.basename(config))[0]\n",
    "        with open(config) as f:\n",
    "            cfg = yaml.load(f, Loader=yaml.FullLoader)\n",
    "        lod_gs, scene = load_gaussians(cfg, config_name, iteration, load_vq, source_path=custom_test)\n",
    "        lod_gs = BlockedGaussian(lod_gs, lp, range=[lp.dist_threshold[i], lp.dist_threshold[i+1]], compute_cov3D_python=pp.compute_cov3D_python)\n",
    "        lod_gs_list.append(lod_gs)\n",
    "\n",
    "    if custom_test:\n",
    "        lp.source_path = custom_test\n",
    "        filename = os.path.basename(lp.source_path)\n",
    "\n",
    "    bg_color = [1,1,1] if lp.white_background else [0, 0, 0]\n",
    "    background = torch.tensor(bg_color, dtype=torch.float32, device=\"cuda\")\n",
    "    \n",
    "    if custom_test:\n",
    "        views = scene.getTrainCameras() + scene.getTestCameras()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_center_list = []\n",
    "for idx in range(len(views)):\n",
    "    viewpoint_cam = loadCamV2(lp, idx, views[idx], 1.0, -180, None)\n",
    "    cam_center_list.append(viewpoint_cam.camera_center.detach().cpu().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('seaborn-white')\n",
    "plt.figure(figsize=(10, 10))\n",
    "for idx in range(len(views)):\n",
    "    color = 'r'\n",
    "    if 0 <= idx < 57:\n",
    "        color = 'g'\n",
    "    cam_center = cam_center_list[idx]\n",
    "    plt.scatter(cam_center[0], cam_center[2], s=100, c=color, marker='x')\n",
    "    # plt.text(cam_center[0], cam_center[1], f'{idx}', fontsize=12)\n",
    "\n",
    "# cam_centers = np.array(cam_center_list)\n",
    "# pose1_center = cam_centers[np.where(cam_centers[:, 2] == cam_centers[:, 2].max())]\n",
    "# pose2_center = cam_centers[np.where(cam_centers[:, 0] == cam_centers[:, 0].max())]\n",
    "# pose3_center = cam_centers[np.where(cam_centers[:, 2] == cam_centers[:, 2].min())]\n",
    "# pose4_center = cam_centers[np.where(cam_centers[:, 0] == cam_centers[:, 0].min())]\n",
    "\n",
    "# plt.scatter(pose1_center[0][0], pose1_center[0][2], s=100, c='b', marker='x')\n",
    "# plt.text(pose1_center[0][0], pose1_center[0][2], '1', fontsize=12)\n",
    "# plt.scatter(pose2_center[0][0], pose2_center[0][2], s=100, c='b', marker='x')\n",
    "# plt.text(pose2_center[0][0], pose2_center[0][2], '2', fontsize=12)\n",
    "# plt.scatter(pose3_center[0][0], pose3_center[0][2], s=100, c='b', marker='x')\n",
    "# plt.text(pose3_center[0][0], pose3_center[0][2], '3', fontsize=12)\n",
    "# plt.scatter(pose4_center[0][0], pose4_center[0][2], s=100, c='b', marker='x')\n",
    "# plt.text(pose4_center[0][0], pose4_center[0][2], '4', fontsize=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find corner poses\n",
    "cam_centers = np.array(cam_center_list)\n",
    "pose1_center = cam_centers[np.where(cam_centers[:, 2] == cam_centers[:, 2].max())]\n",
    "pose2_center = cam_centers[np.where(cam_centers[:, 0] == cam_centers[:, 0].max())]\n",
    "pose3_center = cam_centers[np.where(cam_centers[:, 2] == cam_centers[:, 2].min())]\n",
    "pose4_center = cam_centers[np.where(cam_centers[:, 0] == cam_centers[:, 0].min())]\n",
    "\n",
    "scale_factor = 0.6\n",
    "region_center = (pose1_center[0] + pose2_center[0] + pose3_center[0] + pose4_center[0]) / 4\n",
    "pose1_center = region_center + scale_factor * (pose1_center[0] - region_center)\n",
    "pose2_center = region_center + scale_factor * (pose2_center[0] - region_center)\n",
    "pose3_center = region_center + scale_factor * (pose3_center[0] - region_center)\n",
    "pose4_center = region_center + scale_factor * (pose4_center[0] - region_center)\n",
    "\n",
    "pose1 = views[np.where(cam_centers[:, 2] == cam_centers[:, 2].max())[0].item()]\n",
    "pose2 = views[np.where(cam_centers[:, 0] == cam_centers[:, 0].max())[0].item()]\n",
    "pose3 = views[np.where(cam_centers[:, 2] == cam_centers[:, 2].min())[0].item()]\n",
    "pose4 = views[np.where(cam_centers[:, 0] == cam_centers[:, 0].min())[0].item()]\n",
    "\n",
    "poses = [pose1, pose2, pose3, pose4, pose1, pose2]\n",
    "pose_centers = [pose1_center, pose2_center, pose3_center, pose4_center, pose1_center, pose2_center]\n",
    "\n",
    "video_path = os.path.join(model_path, config_name, \"ours_lod_video\")\n",
    "makedirs(video_path, exist_ok=True)\n",
    "frames = []\n",
    "\n",
    "for idx in range(len(poses) - 2):\n",
    "    angle = np.arctan2(pose_centers[idx+1][2] - pose_centers[idx][2], pose_centers[idx+1][0] - pose_centers[idx][0]) + np.pi / 2\n",
    "\n",
    "    # print(\"Current Anlge: \", angle * 180 / np.pi)\n",
    "    step = 0.005\n",
    "    for t in np.arange(0, 1 + step, step):\n",
    "        xyz = (1 - t) * pose_centers[idx] + t * pose_centers[idx+1]\n",
    "        viewpoint_cam = loadCamV3(lp, idx, poses[idx], 1.0, xyz=xyz, z_dim=1, yaw=angle)\n",
    "        img = render_lod(viewpoint_cam, lod_gs_list, pp, background)[\"render\"]\n",
    "        img = (img * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).cpu().numpy()\n",
    "        frames.append(img)\n",
    "\n",
    "    \n",
    "    step=0.02\n",
    "    angle_next = np.arctan2(pose_centers[idx+2][2] - pose_centers[idx+1][2], pose_centers[idx+2][0] - pose_centers[idx+1][0]) + np.pi / 2\n",
    "\n",
    "    if np.abs(angle_next - angle) > np.pi:\n",
    "        if angle_next > angle:\n",
    "            angle_next -= 2 * np.pi\n",
    "        else:\n",
    "            angle_next += 2 * np.pi\n",
    "    # print(\"Next Anlge: \", angle_next * 180 / np.pi, \"\\n\")\n",
    "    for t in np.arange(step, 1, step):\n",
    "        angle_tmp = (1 - t) * angle + t * angle_next\n",
    "        viewpoint_cam = loadCamV3(lp, idx, poses[idx], 1.0, xyz=xyz, z_dim=1, yaw=angle_tmp)\n",
    "        img = render_lod(viewpoint_cam, lod_gs_list, pp, background)[\"render\"]\n",
    "        img = (img * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).cpu().numpy()\n",
    "        frames.append(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Video saved to ../output/block_rubble_all_lr_c9_loss_12_r4_lod/block_rubble_all_lr_c9_loss_12_r4_60_lr64_vq/ours_lod_video\n"
     ]
    }
   ],
   "source": [
    "video = imageio.get_writer(os.path.join(video_path, \"video.mp4\"), mode=\"I\", fps=30, codec=\"libx264\", bitrate=\"16M\", quality=10)\n",
    "for frame in frames:\n",
    "    video.append_data(frame)\n",
    "video.close()\n",
    "print(f'Video saved to {video_path}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 No LoD, MatrixCity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading camera 741/741\n"
     ]
    }
   ],
   "source": [
    "load_vq = True\n",
    "iteration = 30_000\n",
    "custom_test = '../data/matrix_city/aerial/test/block_all_test'\n",
    "if load_vq:\n",
    "    iteration = None\n",
    "\n",
    "config = \"../config/block_mc_aerial_block_all_lr_c36_loss_5_50_lr64_vq.yaml\"\n",
    "model_path = os.path.join('../output', os.path.basename(config).split('.')[0])\n",
    "with open(config) as f:\n",
    "    cfg = yaml.load(f, Loader=yaml.FullLoader)\n",
    "    lp, op, pp = parse_cfg(cfg)\n",
    "    setattr(lp, 'config_path', config)\n",
    "    if lp.model_path == '':\n",
    "        lp.model_path = model_path\n",
    "\n",
    "with torch.no_grad():\n",
    "    modules = __import__('scene')\n",
    "    model_config = lp.model_config\n",
    "    gaussians = getattr(modules, model_config['name'])(lp.sh_degree, **model_config['kwargs'])\n",
    "\n",
    "    if custom_test:\n",
    "        lp.source_path = custom_test\n",
    "        filename = os.path.basename(lp.source_path)\n",
    "    scene = LargeScene(lp, gaussians, load_iteration=iteration, load_vq=load_vq, shuffle=False)\n",
    "\n",
    "    bg_color = [1,1,1] if lp.white_background else [0, 0, 0]\n",
    "    background = torch.tensor(bg_color, dtype=torch.float32, device=\"cuda\")\n",
    "    \n",
    "    if custom_test:\n",
    "        views = scene.getTrainCameras() + scene.getTestCameras()\n",
    "\n",
    "org_scaling = gaussians._scaling.clone()\n",
    "org_opacity = gaussians._opacity.clone()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_center_list = []\n",
    "dim = 1\n",
    "for idx in range(len(views)):\n",
    "    Rt = np.zeros((4, 4))\n",
    "    Rt[:3, :3] = views[idx].R.transpose()\n",
    "    Rt[:3, 3] = views[idx].T\n",
    "    Rt[3, 3] = 1.0\n",
    "\n",
    "    C2W = np.linalg.inv(Rt)\n",
    "    cam_center_list.append(C2W[:3, -1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.1 Get Convex Hull of Training / Test Poses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7811c3fc10>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.style.use('seaborn-white')\n",
    "plt.figure(figsize=(6, 6))\n",
    "plt.axis('equal')\n",
    "for idx in range(len(views)):\n",
    "    color = 'r'\n",
    "    cam_center = cam_center_list[idx]\n",
    "    plt.scatter(cam_center[0], cam_center[dim], s=100, c=color, marker='x')\n",
    "    # plt.text(cam_center[0], cam_center[1], f'{idx}', fontsize=12)\n",
    "\n",
    "cam_center_array = np.array(cam_center_list)\n",
    "hull = ConvexHull(np.array(cam_center_array)[:, [0, dim]], 'Qg')\n",
    "hull_list=hull.vertices.tolist()\n",
    "\n",
    "simplified_hull = []\n",
    "dist = 3\n",
    "for idx in range(len(hull_list)):\n",
    "    dist_1 = np.linalg.norm(cam_center_array[hull_list[idx], [0, dim]] - cam_center_array[hull_list[idx-1], [0, dim]])\n",
    "    if dist_1 > dist:\n",
    "        simplified_hull.append(hull_list[idx])\n",
    "        \n",
    "simplified_hull = simplified_hull[2:] + simplified_hull[:2]\n",
    "simplified_hull.append(simplified_hull[0])\n",
    "\n",
    "plt.plot(cam_center_array[simplified_hull,0], cam_center_array[simplified_hull, dim], 'b--^',lw=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.2 Fly Around the Whole Scene"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ INFO ] Encountered quite large input images (>1.6K pixels width), rescaling to 1.6K.\n",
      " If this is not desired, please explicitly specify '--resolution/-r' as 1\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_31790/647889563.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     47\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     48\u001b[0m         \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlegend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfontsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfontsize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 49\u001b[0;31m     \u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     50\u001b[0m     \u001b[0mbuf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuffer_rgba\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m     \u001b[0mbev_map\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m...\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    434\u001b[0m              (self.toolbar._wait_cursor_for_draw_cm() if self.toolbar\n\u001b[1;32m    435\u001b[0m               else nullcontext()):\n\u001b[0;32m--> 436\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    437\u001b[0m             \u001b[0;31m# A GUI class may be need to update a window using this draw, so\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    438\u001b[0m             \u001b[0;31m# don't forget to call the superclass.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     72\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     73\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mdraw_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 74\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     75\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_rasterizing\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     76\u001b[0m             \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_rasterizing\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     49\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   2844\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2845\u001b[0m             mimage._draw_list_compositing_images(\n\u001b[0;32m-> 2846\u001b[0;31m                 renderer, self, artists, self.suppressComposite)\n\u001b[0m\u001b[1;32m   2847\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2848\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0msfig\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubfigs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    130\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    131\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 132\u001b[0;31m             \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    133\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    134\u001b[0m         \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     49\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   3090\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3091\u001b[0m         mimage._draw_list_compositing_images(\n\u001b[0;32m-> 3092\u001b[0;31m             renderer, self, artists, self.figure.suppressComposite)\n\u001b[0m\u001b[1;32m   3093\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3094\u001b[0m         \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'axes'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    130\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    131\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 132\u001b[0;31m             \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    133\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    134\u001b[0m         \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     49\u001b[0m                 \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     52\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/legend.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m    618\u001b[0m         \u001b[0;31m# update the location and size of the legend. This needs to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    619\u001b[0m         \u001b[0;31m# be done in any case to clip the figure right.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 620\u001b[0;31m         \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_legend_box\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_window_extent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    621\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlegendPatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_bounds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwidth\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mheight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    622\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlegendPatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_mutation_scale\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfontsize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/offsetbox.py\u001b[0m in \u001b[0;36mget_window_extent\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m    349\u001b[0m         \u001b[0;31m# docstring inherited\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    350\u001b[0m         \u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moffsets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_extent_offsets\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 351\u001b[0;31m         \u001b[0mpx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_offset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0myd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    352\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mmtransforms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mBbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_bounds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpx\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mxd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpy\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0myd\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    353\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/offsetbox.py\u001b[0m in \u001b[0;36mget_offset\u001b[0;34m(self, width, height, xdescent, ydescent, renderer)\u001b[0m\n\u001b[1;32m    289\u001b[0m         \"\"\"\n\u001b[1;32m    290\u001b[0m         return (self._offset(width, height, xdescent, ydescent, renderer)\n\u001b[0;32m--> 291\u001b[0;31m                 \u001b[0;32mif\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_offset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    292\u001b[0m                 else self._offset)\n\u001b[1;32m    293\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/legend.py\u001b[0m in \u001b[0;36m_findoffset\u001b[0;34m(self, width, height, xdescent, ydescent, renderer)\u001b[0m\n\u001b[1;32m    587\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    588\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_loc\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# \"best\".\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 589\u001b[0;31m             \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_find_best_position\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwidth\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    590\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_loc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mLegend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# Fixed location.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    591\u001b[0m             \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_bounds\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwidth\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/legend.py\u001b[0m in \u001b[0;36m_find_best_position\u001b[0;34m(self, width, height, renderer, consider)\u001b[0m\n\u001b[1;32m   1032\u001b[0m                        \u001b[0;34m+\u001b[0m \u001b[0mlegendBox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount_contains\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moffsets\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1033\u001b[0m                        \u001b[0;34m+\u001b[0m \u001b[0mlegendBox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount_overlaps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbboxes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1034\u001b[0;31m                        + sum(line.intersects_bbox(legendBox, filled=False)\n\u001b[0m\u001b[1;32m   1035\u001b[0m                              for line in lines))\n\u001b[1;32m   1036\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mbadness\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mcount_contains\u001b[0;34m(self, vertices)\u001b[0m\n\u001b[1;32m    602\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    603\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 604\u001b[0;31m         \u001b[0mvertices\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvertices\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    605\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrstate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minvalid\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'ignore'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    606\u001b[0m             return (((self.min < vertices) &\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# find corner poses\n",
    "pose_centers = cam_center_array[simplified_hull]\n",
    "poses = [views[i] for i in simplified_hull]\n",
    "\n",
    "scale_factor = 0.8\n",
    "region_center = np.mean(pose_centers, axis=0)\n",
    "pose_centers = region_center + scale_factor * (pose_centers - region_center)\n",
    "pose_centers = np.vstack((pose_centers, pose_centers[0]))\n",
    "\n",
    "video_path = os.path.join(lp.model_path, filename, \"ours_lod_video\")\n",
    "makedirs(video_path, exist_ok=True)\n",
    "frames = []\n",
    "pose_per_segment = 50\n",
    "\n",
    "# second parameter appoints number of points interpolated between each consecutive points to draw the curve\n",
    "interp_xyz = evaluate_bezier(pose_centers, pose_per_segment)\n",
    "xyz_pre = None\n",
    "\n",
    "fontsize = 20\n",
    "fig = plt.Figure(figsize=(12, 9), dpi=100)\n",
    "fig.set_tight_layout(True)\n",
    "canvas = FigureCanvasAgg(fig)\n",
    "ax = fig.gca()\n",
    "gs_xyz = gaussians.get_xyz.cpu().detach().numpy()\n",
    "ax.scatter(gs_xyz[::200, 0], gs_xyz[::200, dim], c='dimgrey', s=0.5)\n",
    "# ax.plot(cam_center_array[simplified_hull,0], cam_center_array[simplified_hull, dim], 'r--^',lw=2)\n",
    "ax.axis('equal')\n",
    "ax.set_xlabel('x/100m', fontsize=fontsize)\n",
    "ax.set_ylabel('y/100m', fontsize=fontsize)\n",
    "ax.tick_params(axis='both', which='major', labelsize=fontsize)\n",
    "ax.set_xlim(np.min(cam_center_array[:, 0]), np.max(cam_center_array[:, 0]))\n",
    "ax.set_ylim(np.min(cam_center_array[:, dim]), np.max(cam_center_array[:, dim]))\n",
    "\n",
    "plt.style.use('seaborn-white')\n",
    "for t in range(len(interp_xyz)):\n",
    "    xyz = interp_xyz[t]\n",
    "\n",
    "    if t == 0:\n",
    "        delta = interp_xyz[t + 1] - interp_xyz[t]\n",
    "    else:\n",
    "        delta = xyz - xyz_pre\n",
    "    \n",
    "    if not np.any(delta):\n",
    "        continue\n",
    "    \n",
    "    ax.scatter(xyz[0], xyz[dim], s=100, c='r', marker='x', label='poses')\n",
    "    if t == 0:\n",
    "        ax.legend(fontsize=fontsize)\n",
    "    canvas.draw()\n",
    "    buf = canvas.buffer_rgba()\n",
    "    bev_map = np.asarray(buf)[..., :3]\n",
    "\n",
    "    angle = np.arctan2(delta[dim], delta[0])\n",
    "\n",
    "    # for matrix city, z_dim=2, otherwise z_dim=1\n",
    "    viewpoint_cam = loadCamV3(lp, idx, poses[0], 1.0, xyz=xyz, z_dim=2, yaw=angle)\n",
    "    img = render(viewpoint_cam, gaussians, pp, background)[\"render\"]\n",
    "    img = (img * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).cpu().numpy()\n",
    "\n",
    "    img = np.concatenate([img, bev_map], axis=1)\n",
    "    \n",
    "    frames.append(img)\n",
    "\n",
    "    xyz_pre = xyz\n",
    "\n",
    "plt.imshow(bev_map)\n",
    "plt.axis('off')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.3 Fly Around Certain Point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 11782801/11782801 [04:38<00:00, 42379.05it/s]\n"
     ]
    }
   ],
   "source": [
    "xyz = gaussians.get_xyz.cpu().detach().numpy()\n",
    "# mask = ((xyz[:, 0] < -3.5) & (xyz[:, 2] > 1.0)) | ((xyz[:, 0] >= -3.5) & (xyz[:, 0] < -0.8) & (xyz[:, 2] > 1.4)) | \\\n",
    "#            ((xyz[:, 0] > 5.0) & (xyz[:, 2] > 2.2))\n",
    "\n",
    "pose_centers = np.array([\n",
    "    [3.2, 5.8, 3.5],\n",
    "    [1.2, 3.8, 2.5],\n",
    "    [3.2, 1.8, 1.8],\n",
    "    [5.2, 3.8, 2.5],\n",
    "    [3.2, 5.8, 3.5],\n",
    "    [-3.0, 4.1, 5.0],\n",
    "    [-7.37, -0.46, 5.0],\n",
    "    [-3.16, -4.7,  6.0],\n",
    "    [3.5, -5.74, 5.0],\n",
    "    [7, -2, 5.0],\n",
    "    [5.0, 1.0, 3.0],\n",
    "    [2.0, 0.5, 2.0],\n",
    "    [-3.0, 2.9, 2.0],\n",
    "    [-5.5, 1.2, 2.0],\n",
    "    [-4.0, -1, 3.5],\n",
    "    [1.0, 0.0, 6],\n",
    "    [3.5, -1.8, 5.5],\n",
    "    [1.0, -3.6, 4.5],\n",
    "    [0.5, 0, 6],\n",
    "    [0.5, 0, 10],\n",
    "    [0.5, 0, 15],\n",
    "])\n",
    "\n",
    "interp_xyz, acc_pts = evaluate_bezier_v3(pose_centers, 25)  # fixed as 50 for fast floater removement\n",
    "mask = np.zeros(len(xyz), dtype=bool)\n",
    "threhsold = 1.75\n",
    "\n",
    "# one interp point to all gs\n",
    "# for idx in tqdm(range(len(interp_xyz))):\n",
    "#     distance = np.linalg.norm(interp_xyz[None, idx] - xyz, axis=1)\n",
    "#     sorted_dist = np.sort(distance)\n",
    "#     if sorted_dist[0] < threhsold and sorted_dist[:10].mean() > 1.5 * threhsold:\n",
    "#         mask[distance < threhsold] = True\n",
    "\n",
    "# one gs to all interp points\n",
    "for idx in tqdm(range(len(xyz))):\n",
    "    distance = np.linalg.norm(xyz[None, idx] - interp_xyz, axis=1)\n",
    "    mask[idx] = np.min(distance) < threhsold\n",
    "\n",
    "# plt.figure()\n",
    "# plt.style.use('seaborn-white')\n",
    "# plt.axis('equal')\n",
    "# plt.scatter(xyz[::500, 0], xyz[::500, 2], c='dimgrey', s=0.5)\n",
    "# # plt.plot([5, 5], [-5, 10], 'r--')\n",
    "# plt.plot([-10, 8], [2.2, 2.2], 'r--')\n",
    "# plt.xlim(-9, 8)\n",
    "# # plt.ylim(-8, 8)\n",
    "# plt.ylim(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    gaussians._scaling = org_scaling.clone()\n",
    "    gaussians._opacity = org_opacity.clone()\n",
    "    gaussians._scaling[mask] = -1e6\n",
    "    gaussians._opacity[mask] = -1e6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find corner poses\n",
    "region_center1 = np.array([3.2, 2.8, 2.5])\n",
    "region_center2 = np.array([1.4, -2.75, 5.0])\n",
    "radius = 2\n",
    "\n",
    "poses = [views[i] for i in simplified_hull]\n",
    "\n",
    "video_path = os.path.join(lp.model_path, filename, \"ours_lod_video\")\n",
    "makedirs(video_path, exist_ok=True)\n",
    "\n",
    "# second parameter appoints number of points interpolated between each consecutive points to draw the curve\n",
    "xyz_pre = None\n",
    "\n",
    "fontsize = 20\n",
    "fig = plt.Figure(figsize=(12, 9), dpi=100)\n",
    "fig.set_tight_layout(True)\n",
    "canvas = FigureCanvasAgg(fig)\n",
    "ax = fig.gca()\n",
    "gs_xyz = gaussians.get_xyz.cpu().detach().numpy()\n",
    "ax.scatter(gs_xyz[::200, 0], gs_xyz[::200, dim], c='dimgrey', s=0.5)\n",
    "# ax.plot(cam_center_array[simplified_hull,0], cam_center_array[simplified_hull, dim], 'r--^',lw=2)\n",
    "ax.axis('equal')\n",
    "ax.set_xlabel('x/100m', fontsize=fontsize)\n",
    "ax.set_ylabel('y/100m', fontsize=fontsize)\n",
    "ax.tick_params(axis='both', which='major', labelsize=fontsize)\n",
    "ax.set_xlim(np.min(cam_center_array[:, 0]), np.max(cam_center_array[:, 0]))\n",
    "ax.set_ylim(np.min(cam_center_array[:, dim]), np.max(cam_center_array[:, dim]))\n",
    "\n",
    "# First Stage, fly around certain point\n",
    "\n",
    "# step = 0.01\n",
    "# plt.style.use('seaborn-white')\n",
    "# for t in np.arange(0, 1+step, step):\n",
    "#     xyz = region_center2.copy()\n",
    "#     xyz[0] += (radius + 1.0 * np.cos(2 * np.pi * t)) * np.cos(2 * np.pi * t + np.pi / 2)\n",
    "#     xyz[dim] += (radius + 1.0 * np.cos(2 * np.pi * t)) * np.sin(2 * np.pi * t + np.pi / 2)\n",
    "\n",
    "#     xyz[2] += 1.0 * np.cos(2 * np.pi * t)\n",
    "\n",
    "#     if t == 0 or t == 0.25 or t == 0.5 or t == 0.75 or t == 1:\n",
    "#         print(f\"Current Position: {xyz}\")\n",
    "\n",
    "#     delta = region_center2 - xyz\n",
    "    \n",
    "#     if not np.any(delta):\n",
    "#         continue\n",
    "    \n",
    "#     ax.scatter(xyz[0], xyz[dim], s=100, c='r', marker='x', label='poses')\n",
    "#     if t == 0:\n",
    "#         ax.legend(fontsize=fontsize)\n",
    "#     # canvas.draw()\n",
    "#     # buf = canvas.buffer_rgba()\n",
    "#     # bev_map = np.asarray(buf)[..., :3]\n",
    "\n",
    "#     angle = np.arctan2(-delta[0], delta[dim])\n",
    "\n",
    "#     # for matrix city, z_dim=2, otherwise z_dim=1\n",
    "#     viewpoint_cam = loadCamV3(lp, idx, poses[0], 1.0, xyz=xyz, z_dim=2, yaw=angle)\n",
    "#     img = render(viewpoint_cam, gaussians, pp, background)[\"render\"]\n",
    "#     img = (img * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).cpu().numpy()\n",
    "\n",
    "#     # img = np.concatenate([img, bev_map], axis=1)\n",
    "    \n",
    "#     frames.append(img)\n",
    "\n",
    "#     xyz_pre = xyz\n",
    "\n",
    "# Second Stage, fly around the whole scene\n",
    "\n",
    "pose_per_segment = 25\n",
    "pose_centers = np.array([\n",
    "    [3.2, 5.8, 3.5],\n",
    "    [1.2, 3.8, 2.5],\n",
    "    [3.2, 1.8, 1.8],\n",
    "    [5.2, 3.8, 2.5],\n",
    "    [3.2, 5.8, 3.5],\n",
    "    [-3.0, 4.1, 5.0],\n",
    "    [-7.37, -0.46, 5.0],\n",
    "    [-3.16, -4.7,  6.0],\n",
    "    [3.5, -5.74, 5.0],\n",
    "    [7, -2, 5.0],\n",
    "    [5.0, 1.0, 3.0],\n",
    "    [2.0, 0.5, 2.0],\n",
    "    [-3.0, 2.9, 2.0],\n",
    "    [-5.5, 1.2, 2.0],\n",
    "    [-4.0, -1, 3.5],\n",
    "    [1.0, 0.0, 6],\n",
    "    [3.5, -1.8, 5.5],\n",
    "    [1.0, -3.6, 4.5],\n",
    "    [0.5, 0, 6],\n",
    "    [0.5, 0, 10],\n",
    "    [0.5, 0, 15],\n",
    "])\n",
    "\n",
    "interp_xyz, acc_pts = evaluate_bezier_v3(pose_centers, pose_per_segment)\n",
    "\n",
    "Rt = np.zeros((4, 4))\n",
    "Rt[:3, :3] = poses[0].R.transpose()\n",
    "Rt[:3, 3] = poses[0].T\n",
    "Rt[3, 3] = 1.0\n",
    "\n",
    "C2W = np.linalg.inv(Rt)\n",
    "ref_angle = np.array(mat2euler(C2W[:3, :3]))\n",
    "\n",
    "key_point1, interval1 = acc_pts[3], 10\n",
    "key_point2, interval2 = acc_pts[9], 50\n",
    "key_point3, interval3 = acc_pts[14], 50\n",
    "key_point4, interval4 = acc_pts[17], 50\n",
    "# key_point2, interval2 = acc_pts[2], 50\n",
    "# key_point3, interval3 = acc_pts[7], 50\n",
    "# key_point4, interval4 = acc_pts[10], 50\n",
    "xyz_pre = None\n",
    "\n",
    "\n",
    "xyz_list, angle_list = [], []\n",
    "\n",
    "for t in range(len(interp_xyz)):\n",
    "    xyz = interp_xyz[t]\n",
    "    angle = ref_angle.copy()\n",
    "\n",
    "    if xyz_pre is not None and not np.any(xyz - xyz_pre):\n",
    "        continue\n",
    "\n",
    "    if t < key_point1 - 10:\n",
    "        # stage 1\n",
    "        delta = region_center1 - xyz\n",
    "        angle[2] = np.arctan2(delta[0], -delta[dim]) + np.pi\n",
    "        \n",
    "    elif t < key_point1:\n",
    "        # transition\n",
    "        delta = region_center1 - xyz\n",
    "        angle2 = np.arctan2(delta[0], -delta[dim]) + np.pi\n",
    "\n",
    "        delta = xyz - xyz_pre\n",
    "        angle1 = np.arctan2(delta[dim], delta[0])\n",
    "\n",
    "        angle[2] = (1 - (t - key_point1 + interval1 + 1) / interval1) * angle2 + (t - key_point1 + interval1 + 1) / interval1 * angle1\n",
    "\n",
    "        # print(f\"circle: {angle2}, org: {angle1}, current: {angle}\")\n",
    "    \n",
    "    elif t < key_point2 - interval2:\n",
    "        # stage 2\n",
    "\n",
    "        if xyz_pre is None:\n",
    "            delta = interp_xyz[t + 1] - interp_xyz[t]\n",
    "        else:\n",
    "            delta = xyz - xyz_pre\n",
    "        \n",
    "        # delta = xyz - xyz_pre\n",
    "        angle[2] = np.arctan2(delta[dim], delta[0])\n",
    "\n",
    "    elif t < key_point2:\n",
    "        delta = xyz - xyz_pre\n",
    "        angle2 = np.arctan2(delta[dim], delta[0])\n",
    "        angle1 = np.arctan2(-delta[0], delta[dim])\n",
    "        \n",
    "        angle[2] = (1 - (t - key_point2 + interval2 + 1) / interval2) * angle2 + (t - key_point2 + interval2 + 1) / interval2 * angle1\n",
    "\n",
    "    elif t < key_point3 - interval3:\n",
    "        # stage 2\n",
    "        delta = xyz - xyz_pre\n",
    "        angle[2] = np.arctan2(-delta[0], delta[dim])\n",
    "\n",
    "    elif t < key_point3:\n",
    "        # transition\n",
    "        \n",
    "        delta = xyz - xyz_pre\n",
    "        angle2 = np.arctan2(-delta[0], delta[dim])\n",
    "\n",
    "        delta = region_center2 - xyz\n",
    "        angle1 = np.arctan2(delta[0], -delta[dim]) - np.pi\n",
    "\n",
    "        angle[2] = (1 - (t - key_point3 + interval3 + 1) / interval3) * angle2 + (t - key_point3 + interval3 + 1) / interval3 * angle1\n",
    "    \n",
    "    elif t < key_point4 - interval4:\n",
    "        # stage 3\n",
    "        delta = region_center2 - xyz\n",
    "        angle[2] = np.arctan2(delta[0], -delta[dim]) - np.pi\n",
    "    \n",
    "    elif t < key_point4:\n",
    "        # transition\n",
    "        delta = region_center2 - xyz\n",
    "        angle[2] = np.arctan2(delta[0], -delta[dim]) - np.pi\n",
    "\n",
    "        angle[0] = (1 - (t - key_point4 + interval4 + 1) / interval4) * angle[0] + (t - key_point4 + interval4 + 1) / interval4 * (-np.pi)\n",
    "    \n",
    "    else:\n",
    "        # stage 3\n",
    "        delta = region_center2 - xyz\n",
    "        angle[2] = np.arctan2(delta[0], -delta[dim]) - np.pi\n",
    "        angle[0] = -np.pi\n",
    "\n",
    "    xyz_list.append(xyz)\n",
    "    angle_list.append(angle)\n",
    "\n",
    "    xyz_pre = xyz\n",
    "\n",
    "angle_list = np_move_avg_v2(np.unwrap(np.array(angle_list), axis=0), 10, mode='same').tolist()\n",
    "\n",
    "frames = []\n",
    "for t in range(len(xyz_list)):\n",
    "    xyz = xyz_list[t]\n",
    "    angle = angle_list[t]\n",
    "\n",
    "    ax.scatter(xyz[0], xyz[dim], s=100, c='r', marker='x', label='poses')\n",
    "\n",
    "    if t == 0:\n",
    "        ax.legend(fontsize=fontsize)\n",
    "    \n",
    "    # canvas.draw()\n",
    "    # buf = canvas.buffer_rgba()\n",
    "    # bev_map = np.asarray(buf)[..., :3]\n",
    "\n",
    "    # for matrix city, z_dim=2, otherwise z_dim=1\n",
    "    viewpoint_cam = loadCamV4(lp, idx, poses[0], 1.0, xyz=xyz, angle=angle)\n",
    "    img = render(viewpoint_cam, gaussians, pp, background)[\"render\"]\n",
    "    img = (img * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).cpu().numpy()\n",
    "\n",
    "    # img = np.concatenate([img, bev_map], axis=1)\n",
    "    \n",
    "    frames.append(img) \n",
    "\n",
    "# canvas.draw()\n",
    "# buf = canvas.buffer_rgba()\n",
    "# bev_map = np.asarray(buf)[..., :3]\n",
    "# plt.imshow(bev_map)\n",
    "# plt.axis('off')\n",
    "\n",
    "# plt.figure()\n",
    "# plt.plot(np.array(angle_list)[:, 2] * 180 / np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.4 Straight Line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find corner poses\n",
    "selected_poses = [simplified_hull[0]] + [simplified_hull[4]]\n",
    "pose_centers = cam_center_array[selected_poses]\n",
    "poses = [views[i] for i in selected_poses]\n",
    "\n",
    "scale_factor = 0.5\n",
    "region_center = np.mean(pose_centers, axis=0)\n",
    "pose_centers = region_center + scale_factor * (pose_centers - region_center)\n",
    "pose_centers = np.vstack((pose_centers, pose_centers[0]))\n",
    "\n",
    "video_path = os.path.join(lp.model_path, filename, \"ours_lod_video\")\n",
    "makedirs(video_path, exist_ok=True)\n",
    "frames = []\n",
    "pose_per_segment = 50\n",
    "\n",
    "# second parameter appoints number of points interpolated between each consecutive points to draw the curve\n",
    "interp_xyz = evaluate_bezier(pose_centers, pose_per_segment)\n",
    "xyz_pre = None\n",
    "\n",
    "fontsize = 20\n",
    "fig = plt.Figure(figsize=(12, 9), dpi=100)\n",
    "fig.set_tight_layout(True)\n",
    "canvas = FigureCanvasAgg(fig)\n",
    "ax = fig.gca()\n",
    "gs_xyz = gaussians.get_xyz.cpu().detach().numpy()\n",
    "ax.scatter(gs_xyz[::200, 0], gs_xyz[::200, dim], c='dimgrey', s=0.5)\n",
    "# ax.plot(cam_center_array[simplified_hull,0], cam_center_array[simplified_hull, dim], 'r--^',lw=2)\n",
    "ax.axis('equal')\n",
    "ax.set_xlabel('x/100m', fontsize=fontsize)\n",
    "ax.set_ylabel('y/100m', fontsize=fontsize)\n",
    "ax.tick_params(axis='both', which='major', labelsize=fontsize)\n",
    "ax.set_xlim(np.min(cam_center_array[:, 0]), np.max(cam_center_array[:, 0]))\n",
    "ax.set_ylim(np.min(cam_center_array[:, dim]), np.max(cam_center_array[:, dim]))\n",
    "\n",
    "plt.style.use('seaborn-white')\n",
    "for t in range(len(interp_xyz)):\n",
    "    xyz = interp_xyz[t]\n",
    "\n",
    "    if t == 0:\n",
    "        delta = interp_xyz[t + 1] - interp_xyz[t]\n",
    "    else:\n",
    "        delta = xyz - xyz_pre\n",
    "    \n",
    "    if not np.any(delta):\n",
    "        continue\n",
    "    \n",
    "    ax.scatter(xyz[0], xyz[dim], s=100, c='r', marker='x', label='poses')\n",
    "    if t == 0:\n",
    "        ax.legend(fontsize=fontsize)\n",
    "    canvas.draw()\n",
    "    buf = canvas.buffer_rgba()\n",
    "    bev_map = np.asarray(buf)[..., :3]\n",
    "\n",
    "    angle = np.arctan2(-delta[0], delta[dim])\n",
    "\n",
    "    # for matrix city, z_dim=2, otherwise z_dim=1\n",
    "    viewpoint_cam = loadCamV3(lp, idx, poses[0], 1.0, xyz=xyz, z_dim=2, yaw=angle)\n",
    "    img = render(viewpoint_cam, gaussians, pp, background)[\"render\"]\n",
    "    img = (img * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).cpu().numpy()\n",
    "\n",
    "    img = np.concatenate([img, bev_map], axis=1)\n",
    "    \n",
    "    frames.append(img)\n",
    "\n",
    "    xyz_pre = xyz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.5 Save Video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (1600, 900) to (1600, 912) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to 1 (risking incompatibility).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Video saved to ../output/block_mc_aerial_block_all_lr_c36_loss_5_50_lr64_vq/block_all_test/ours_lod_video\n"
     ]
    }
   ],
   "source": [
    "video = imageio.get_writer(os.path.join(video_path, \"video.mp4\"), mode=\"I\", fps=30, codec=\"libx264\", bitrate=\"16M\", quality=10)\n",
    "for frame in frames:\n",
    "    video.append_data(frame)\n",
    "video.close()\n",
    "print(f'Video saved to {video_path}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 No LoD, Other Scene"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading trained model at iteration 30000\n",
      "Reading camera 2998/2998\n"
     ]
    }
   ],
   "source": [
    "load_vq = False\n",
    "iteration = 30_000\n",
    "custom_test = '../data/urban_scene_3d/sci-art-pixsfm/train'\n",
    "if load_vq:\n",
    "    iteration = None\n",
    "\n",
    "config = \"../config/block_sciart_all_lr_c9_loss_5_r4.yaml\"\n",
    "model_path = os.path.join('../output', os.path.basename(config).split('.')[0])\n",
    "with open(config) as f:\n",
    "    cfg = yaml.load(f, Loader=yaml.FullLoader)\n",
    "    lp, op, pp = parse_cfg(cfg)\n",
    "    setattr(lp, 'config_path', config)\n",
    "    if lp.model_path == '':\n",
    "        lp.model_path = model_path\n",
    "\n",
    "with torch.no_grad():\n",
    "    modules = __import__('scene')\n",
    "    model_config = lp.model_config\n",
    "    gaussians = getattr(modules, model_config['name'])(lp.sh_degree, **model_config['kwargs'])\n",
    "\n",
    "    if custom_test:\n",
    "        lp.source_path = custom_test\n",
    "        filename = os.path.basename(lp.source_path)\n",
    "    scene = LargeScene(lp, gaussians, load_iteration=iteration, load_vq=load_vq, shuffle=False)\n",
    "\n",
    "    bg_color = [1,1,1] if lp.white_background else [0, 0, 0]\n",
    "    background = torch.tensor(bg_color, dtype=torch.float32, device=\"cuda\")\n",
    "    \n",
    "    if custom_test:\n",
    "        views = scene.getTrainCameras() + scene.getTestCameras()\n",
    "    \n",
    "    org_scaling = gaussians._scaling.clone()\n",
    "    org_opacity = gaussians._opacity.clone()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/yang_liu/anaconda3/envs/gaussian_splatting/lib/python3.7/site-packages/ipykernel_launcher.py:5: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  \"\"\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimension of Voxels: tensor([35, 30])\n"
     ]
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    voxel_size = torch.tensor([10, 10])\n",
    "    xy_range = torch.tensor([-200, -200, 150, 100])\n",
    "    org_xyz = gaussians.get_xyz.cpu()\n",
    "    voxel_index = torch.div(torch.tensor(org_xyz[:, [0, 2]]).float() - xy_range[None, :2], voxel_size[None, :], rounding_mode='floor')\n",
    "    voxel_coords = voxel_index * voxel_size[None, :] + xy_range[None, :2] + voxel_size[None, :] / 2\n",
    "    voxel_dim = torch.tensor([int((xy_range[2] - xy_range[0]) / voxel_size[0]), int((xy_range[3] - xy_range[1]) / voxel_size[1])])\n",
    "    print(f\"Dimension of Voxels: {voxel_dim}\")\n",
    "\n",
    "    new_coors, unq_inv, unq_cnt = torch.unique(voxel_coords, return_inverse=True, return_counts=True, dim=0)\n",
    "    feat_mean = torch_scatter.scatter(org_xyz[:, 1], unq_inv, dim=0, reduce='mean')\n",
    "    feat_std = torch_scatter.scatter_std(org_xyz[:, 1], unq_inv, dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAGuCAYAAABP8nZtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABH1klEQVR4nO3deZwUxf3/8feerFyrLhBAcFUIoMLqwqosIiiLrsGAogYUENEVQ4zXJsYbBETB4ysi3oAEUORHJBqDxAsxXw9UNoKIongAEYnALlFEEBa2f3/Mt+fauWd6pnvm9Xw85rEwU9NTXd1d9Zmq6poswzAMAQAApFh2qjMAAAAgEZQAAACbICgBAAC2QFACAABsgaAEAADYAkEJAACwBYISAABgCwQlAADAFghKAACALRCUAGmqa9eumjlzZko+e8CAAbr55ptT8tnBzJo1S2effbYaGhpSnRXLfPnllzruuOO0YcOGVGcFiAlBCRCDcePG6YQTTtDu3buDpvnjH/+o7t2767///W8ScxadLVu2qGvXrpozZ06qs2Kp3bt3a/bs2Ro7dqyys13V3n//+1/Nnj1bI0eOVO/evVVWVqZhw4Zp2bJlAbexbt06VVVVqWfPniotLdXll1+u9evXx5Wvxx57TOPGjVOfPn1CBpEzZ85U165dGz169Ojhk65z587q37+/HnroobjyBaRKbqozADjRkCFDtGLFCr3++us677zzGr2+d+9evfHGG+rbt68OO+yw5GcQPp577jkdOHBAv/71r93PrVmzRg8++KD69eun3/3ud8rNzdUrr7yi6upqffnll7r22mvdaT/55BONGDFC7dq109VXX62GhgYtXLhQo0aN0l/+8hcdc8wxMeXrwQcfVOvWrXXsscfq7bffDpt+4sSJatq0qfv/OTk5jdJcdNFFuvLKK/Xvf/9bRx55ZEz5AlKFoASIwYABA9SsWTP9/e9/DxiULF++XHv27NGQIUOSnzk08te//lUDBgxQkyZN3M917txZr7zyio444gj3cyNGjNCYMWM0a9YsXXHFFe4AYMaMGSooKNCiRYvcQeaQIUNUWVmp6dOnxzxMtnz5cnXo0EE7d+5UeXl52PSVlZU6/PDDQ6bp06ePCgsL9fzzz+u6666LKV9AqjB8A8SgoKBAZ511lt577z3V1dU1en3p0qVq1qyZBgwYIEn65ptvdO211+rkk0/WCSecoGHDhunNN990p//qq69UUlKiG2+80Wc7NTU1OvbYY3Xfffe5n9u1a5fuuusu9e/fX927d9eZZ56pJ598MmFzJf7617+qa9eu+te//qWpU6eqd+/eOvHEE/X73/9eO3fu9ElrGIYeffRR9evXTyeccIIuueQSffHFFwG3Gy7fhmHokksuUe/evX3KdP/+/Ro8eLAGDhyoPXv2uJ//6quvtHXr1rD788033+jzzz9Xnz59fJ7v2LGjT0AiSVlZWRo4cKD279+vb775xv18TU2NysvLfXq92rRpo5NPPlkrVqzQTz/9FDYfgXTo0CHq9+zevVuhftw9Ly9PJ598spYvXx5TnoBUIigBYjR48GAdOHBA//jHP3ye//777/X222/rzDPPVEFBgWpra3XRRRfp7bff1sUXX6zq6mrt27dPv/vd7/Taa69Jkjp16qTrrrtOf/vb39yNyZ49e3TLLbfomGOOcX/j3bt3r0aNGqUXX3xR5513nm6//Xb17NlTDzzwgKZOnZrQ/ZsyZYo+++wzXX311br44ou1YsUKTZ482SfNjBkzNGPGDHXr1k033nijOnbsqMsvv9wneIg031lZWbr77ru1b98+3XHHHe73zpw5U1988YWmTp3qM3QxaNAg3XTTTWH3Y/Xq1ZKk4447LqL9rq2tlSSfAGT//v0qKCholLagoED19fVBA7FEq6ioUK9evdSzZ0/dcMMN7rz6O/744/XFF1+EnPME2BHDN0CMevfurdatW2vp0qUaNWqU+/mXX35Z9fX1Gjx4sCTpySefVG1trZ555hmVlZVJkn7zm99oyJAhmjp1qioqKpSdna3LLrtMy5cv14QJE9SzZ0/NnDlTW7du1aJFi5Sfny9Jmjt3rr755hs9//zzOuqooyS55hC0adNGc+bM0eWXX6527dolZP8OPfRQPfXUU8rKypIkNTQ0aMGCBfrxxx/VokUL7dy5U7Nnz9bpp5+uxx9/3J1u+vTpevzxx322FWm+O3bsqJtvvlkTJkzQiy++qOLiYs2ZM0ejR4/WSSedFNN+fP3115Ii65X4/vvv9Ze//EVlZWVq06aN+/mjjz5aa9as0cGDB93zOPbv36+1a9dKkrZt2xZT3iLVsmVLjRo1SieeeKLy8/NVU1OjhQsX6uOPP9aSJUvUvHlzn/QdO3ZUQ0ODvv76a5WUlFiaNyCR6CkBYpSTk6NzzjlHq1ev1pYtW9zPL126VK1atXLPEfjnP/+pkpISd0AiSc2aNdPw4cP17bff6ssvv5QkZWdna9q0adqzZ4/Gjh2rhQsX6sorr/S5w+Lll19Wr1691LJlS+3cudP96NOnjw4ePKhVq1YlbP+GDRvmDjQkqaysTAcPHtS3334rSXr33XdVX1+vUaNG+aS79NJLG20rmnwPHz5cffv21ZQpU9y9L3/4wx8abfPzzz/XggULwu7H999/r9zcXDVr1ixkuoaGBt1www3atWuXxo8f7/PaiBEjtGnTJt1222368ssvtWHDBt10003asWOHJOnnn38Om494XHrppRo/frwGDx6syspK3XbbbZo2bZo2bdqkhQsXNkrfsmVLSbL1nV9AIPSUAHEYPHiw/vznP2vp0qUaN26cvvvuO9XU1OiSSy5xf6PeunWrTjjhhEbvNe/Y2Lp1q7p06SJJOvLII3X11Vfr3nvvVZcuXXTVVVf5vGfz5s36/PPPg06K9J/zEY/27dv7/N9s6Hbt2uXOtyR3z4fp8MMPV2Fhoc9z0eb77rvv1sCBA/XDDz9o0aJFAYdOEu3OO+/UW2+9pXvuuUfdunXzee3iiy/Wd999pzlz5uj555+XJHXv3l1VVVV6/PHHwwY8Vhg8eLDuuecevfvuu7ryyit9Xgs15wSwM4ISIA7du3fXMccco5deeknjxo3T0qVLZRiGe+gmFu+8844kafv27fr+++/VunVr92sNDQ069dRTdcUVVwR8r3+AEA9zPQ9/sTR40eb7/fff1/79+yVJGzZsUGlpadSfaTr00EN14MAB7d69u9Ewh+nhhx/WwoUL9cc//jHg3VSSVF1drcsvv1xffPGFWrRooa5du+qBBx4ImP9kadu2rX744YdGz5uBI7ejw2kISoA4DR48WDNmzNBnn32mpUuX6qijjvIZx2/fvr02btzY6H3mXAfvHolnn31W77zzjqqrq/XEE09owoQJeuyxx9yvH3nkkdqzZ0+jO0lSwcz3pk2b1LFjR/fzO3fubNRQRpPv7du3a8qUKerbt6/y8vJ0zz33qG/fvo3ulImU2SO1ZcuWRj0gkvTMM89o5syZuvTSSxv1OPgrLCz0GYZ799131bZt25jXKYmHYRj69ttvA07g3bJli7Kzs3X00UcnPV9APJhTAsTJ7BV56KGHtH79+ka9JP3799fatWvdd4FIrjtrFi9erCOOOEKdO3eW5Lp19d5771VlZaXGjRunm266SW+88YZeeOEF9/t+9atfafXq1Xrrrbca5WPXrl06cOCABXsYWJ8+fZSXl6enn37ap/dk3rx5jdJGk+/x48eroaFBd911lyZPnqzc3FzddtttjXpoIr0l2OxlWbduXaPXli1bpilTpmjw4MG65ZZbwm7L/70ff/yxLr300qC9SokSaFhu4cKF2rlzp0477bRGr33yySfq3LmzWrRoYWm+gESjpwSIU8eOHVVaWuq+ldc/KLnyyiv10ksvaezYsbrkkktUWFioF154QVu2bNHMmTOVnZ0twzB06623qqCgQBMnTpTkujvl1Vdf1V133aXy8nL94he/UFVVld544w2NGzdOQ4cO1fHHH6+9e/dqw4YNeuWVV7R8+fKwi2slyuGHH67LL79cTzzxhH7729+qf//++vTTT/W///u/jYYNIs33kiVL9Oabb2ratGlq27atJOn222/Xn/70Jy1cuFAjR450b3PQoEE6+eSTw0527dixo7p06aKVK1fqwgsvdD+/du1a3XjjjTr00ENVXl6uF1980ed9PXv2dPcArVq1So888ohOPfVUHXroofroo4/017/+VaeddppGjx7t876ZM2fq4Ycf1vz583XKKaeEzNsLL7ygrVu3uifKrlq1So8++qgk6dxzz3X3Dp1xxhkaNGiQunTpovz8fH344Yd66aWXdOyxx2r48OE+26yvr9eqVat08cUXh/xswI4ISoAEGDx4sFavXq2SkhIVFxf7vNaqVSstWrRI9913n55++mnt27dPXbt21eOPP67TTz9dkrRgwQJ98MEHmjlzpk9Qcdddd+nXv/61xo8fryeffFKHHHKIFixYoCeeeEIvv/yyXnjhBTVv3lxHHXWUrrnmmqR/M77++uuVn5+vRYsW6f3331dJSYmeeuop/fa3v/VJF0m+v/vuO02dOlVnnHGGhg4d6n7vkCFD9Oqrr+r+++9Xv379fIaKInXBBRdoxowZ+vnnn92TZr/88kvV19dr586duvXWWxu9Z+rUqe7P+sUvfqGcnBzNmTNHP/30kzp06KDrr79eY8aMUW6ubzW6Z88eZWVlqVWrVmHztWTJEn3wwQfu/7///vt6//33JUm9evVyByXm+fXKK69o//79at++va644gqNGzdOhxxyiM82V65cqe+//96nDAGnyDKYpg0gzf34448aOHCgbrjhBv3mN7+x9LMuvPBCtW/fPmU/infVVVcpKytLjzzySEo+H4gHc0oApL0WLVqoqqpKc+bMSdhy/IHs3r1bn332Wcp+c+arr77Sm2++yW/ewLHoKQEAALZATwkAALAFghIAAGALBCUAAMAWCEoAAIAtOGqdkrKyMu3fv9/nt0AAAIC97dixQ/n5+aqpqQmZzlFByb59+3Tw4MFUZwMAAEThwIEDEf2Yp6OCkjZt2kiSezlvAABgfxUVFRGlY04JAACwBYISAABgCwQlAADAFghKAACALRCUAAAAWyAoAQAAtkBQAgAAbIGgBAAA2AJBCQAAsAWCEgAAYAsEJQAAwBYISgAAgC0QlAAAAFsgKEknNTXSyJGuvwAAOIxlQcnBgwf14IMPasCAASopKdHAgQP1yCOPyDAMdxrDMDRjxgz17dtXJSUlGjNmjDZt2mRVltLf9OnS4sWuvwAAOEyuVRueNWuWnn32Wd1zzz3q3Lmz1q1bp1tuuUUtWrTQ6NGj3WkWLFigadOmqUOHDpoxY4aqqqq0bNkyNWnSxKqspa/qat+/AAA4iGVByerVq1VRUaHTTz9dktShQwe99NJLWrt2rSRXL8n8+fP1u9/9TgMHDpQk3XvvverTp49ef/11nXPOOVZlLX2VlUnPPJPqXAAAEBPLhm9KS0v13nvvaePGjZKkzz77TP/617/Ur18/SdKWLVu0Y8cO9enTx/2eFi1a6IQTTtDq1autyhYAALApy3pKrrzySu3evVu/+tWvlJOTo4MHD6q6ulpDhgyRJO3YsUOSVFRU5PO+oqIi1dbWWpUtAABgU5YFJf/4xz/097//Xf/zP/+jzp07a/369Zo6daratGmjoUOHWvWxAADAoSwLSu69915deeWV7rkhXbt21datW/XEE09o6NChat26tSSprq5Obdq0cb+vrq5O3bp1sypbAADApiybU/Lzzz8rKyvL57mcnBz3LcEdOnRQ69attXLlSvfru3fv1kcffaTS0lKrsgUAAGzKsp6SM844Q48//rjat2/vHr6ZO3euLrjgAklSVlaWRo8erccee0zFxcXuW4LbtGnjvhsHAABkDsuCkttvv10zZszQpEmT3EM0w4cP1+9//3t3mrFjx2rv3r2aMGGCdu3apV69emn27NmsUQIAgKmmxrUoZnW1a+mHNJZleC+xanMVFRWSpOXLl6c4JwAAJMnIka7VuocNc+xaVJG23/z2DZDJ+L0kwP6qq10BSQas1m3Z8A0ABzB/L0ly7DcwIO1l0GrdBCVAJuP3kgDYCMM3QCYzv4Gl+eQ5oBGGLm2JnhIAQOZh6NKWCEoAAJmHoUtbIigBAGSeDJo86iTMKQEAALZAUAIAAGyBoAQAANgCQQkAALAFghIAAOLFuicJQVACAEC8zHVPpk9PXR7SIDDilmAAAOJlh3VP0mBBOIISAADiZYd1T+wQGMWJ4RsA9pQGXdFAUqXBb1nRUwLAntKgKxpAdAhKANhTGnRFA4gOwzewJ7rukQZd0bZWUyOdfbbr4ZTrjHoh7dFTAnui6x6w1vTp0quvuv5dVOSM64x6Ie0RlMCe6LoHrFVdLdXVef7tBNQLaS/LMAwj1ZmIVEVFhSRp+fLlKc4JAACIVKTtN3NKAACALRCUAACQ6WwyiZg5JQAAZDqbTCKmpwQAADtLRi9GdbU0bFjKJxETlACA3dikKx02kYxfILbJukAM3wCA3dikKx02kUG3QhOUAIDdZFAjhAjY4ReIk4ThGwDRY3jBWjbpSgeSjaAEQPSSMcaN+BA4woEISgBEzyYz9WOWCQ02gSMciDklAKLn9DHuTJhIyrwUOBBBCYDMkwkNttMDR2Qkhm8AOFeswzBMJAVsiZ4SAM6VCcMwQAYhKAHgXJkwDANkEIZvADgXwzDOlgl3QSEqBCVwDqdUYE7JJzhWqcZty/BDUGKicrI/qyqwRB97Klrn4FilltPXu7FChrdFzCkxMWHO/qyaP5DoY888B+fgWKUWty03luFtEUGJicrJ/qyqwBJ97KlonYNjBbvJ8LaI4RsTE+YyV7Bjn4hu1AzvigUQpUS2RQ6sf+gpAYJJRDdqhnfFAkghB9Y/BCVAMInoRs3wrlgAKeTA+ifLMAwj1ZmIVEVFhSRp+fLlKc4JgIjU1Li+rVVXMzQKZLBI22/mlACwDrfcIh05cK6GUxCUpAsuEtgR61AgHRFsW4Y5JYE4scvZgROakAG45RbpyIFzNZyCoCQQJzbwqb5InBjIAUAsCLYtw/BNIE7sck71Oit0ZwKJx7BseuK4BkVPSSBEwdFLdU8NkI6c2GuL8Ox6XG3Q401QgsQgkAMSj2A/Pdn1uNogWCIoAQC7IthPT3Y9rjYIlghKAACALYIlJroCQLpgAmVqUO4JY2lQsm3bNt1www065ZRTVFJSosGDB+vjjz92v24YhmbMmKG+ffuqpKREY8aM0aZNm6zMEgCkL+6CSw3KPWEsG7754YcfdPHFF+uUU07RrFmzdNhhh2nz5s0qLCx0p5k1a5YWLFigadOmqUOHDpoxY4aqqqq0bNkyNWnSxKqsAUB6ssGcgIxEuSeMZT/Id//99+vDDz/UwoULA75uGIZOO+00XXbZZaqqqpIk/fjjj+rTp4+mTZumc845p9F7+EE+AACcJ+U/yPfGG2+oe/fuuvbaa1VeXq7zzjtPi81bjSRt2bJFO3bsUJ8+fdzPtWjRQieccIJWr15tVbYAAIBNWRaUfPPNN3r22Wd11FFHac6cObr44os1ZcoUPf/885KkHTt2SJKKiop83ldUVKTa2lqrsgUAAGzKsqDEMAwdf/zx+sMf/qDjjjtOw4cP17Bhw7Ro0SKrPhIA4FTcwQJZGJS0bt1anTp18nnumGOO0datW92vS1JdXZ1Pmrq6OrVq1cqqbMGpqLCA9MYdLJCFQUnPnj21ceNGn+c2bdqkI444QpLUoUMHtW7dWitXrnS/vnv3bn300UcqLS21KltwKiosIL058YdQkXCW3RJ86aWX6uKLL9bjjz+uX/3qV1q7dq0WL16syZMnS5KysrI0evRoPfbYYyouLnbfEtymTRsNHDjQqmzBqbjlDkhvNlhNFKlnWVBSUlKihx9+WA888IAeeeQRdejQQbfeequGDBniTjN27Fjt3btXEyZM0K5du9SrVy/Nnj2bNUrQGBUWAKQ9y9YpsQLrlAAA4DwpX6cEAAAgGgQlAADAFghKAACALRCUALA/1qkBMgJBCQD7Y52a5ElUAEggiRhYdkswACQM69QkjxkASvHdhp+o7SCjEJQAsD/WqUmeRAWABJKIAcM3AAAPMwAsK7PHdmAdGw6xEZQgs9nwogTSDteZPdlwrhZBCTKbDS9KwBYSGUjEc50R0FjHhj+CyJwSZDbGvYHAEjlRNZ7rjAmz1rHhXC2CEmQ2G16UgC0kMmCP5zrji0NGYfgG8aFrFUhPdpmoapd8ICnoKUF86FoFACQIQQniQ9cqACBBCEoQH+ZkAAAShDklAADAFghKrMIEUAAAokJQYhUW5QIA2IVDvigzp8QqTAAFANiFQ+6UJCixChNAAQB24ZAvygQlAACkO4d8UWZOCQAgPThk3gSCo6cEAJAeHDJvAsHRUwIAsK9oej+qq6Vhw2w/bwLB0VMCALCvaHo/HDJvAsHRUwLA2ZhHkN7o/cgo9JQAcDbmEaQ3ej8yCj0lAJytulqqqJDq6ugtARyOoASAs5WVSUVF0vLl/KwD4HAM3wBwPoesVgkgNIISAM7HvAMgLTB8AwBAprPJXWz0lAAAkOlschcbQQkAAJnOJvOyCEoAAMh0NpmXxZwSAABgCwQlAADAFghKAACALRCUAAAAWyAoAQAAtkBQguBsspgOACAzEJQgOHMxHX7kzJkBmhPzDCCjEZQguOpqadiwlC+mE7dENM5ODNCcmGcAGY2gBMGZi+mUlaU6J/FJROPsxADNO8/0miAczhHYACu6Iv0lYvlkm6x2GBXvPI8caYvftYCN2eS3T5DZCEqQ/pwYUCSaTX7XAjbGOQIbICgBMgGBGcLhHIENMKcEAADYAkEJAACwBYISAABgCwQlAFKH21ABeGGiK4DU4TZUAF4ISgCkDrehAvDC8A2A+MU6DJMuqwYDSAh6SgDEj2EYAAmQtJ6SJ598Ul27dtVdd93lfm7fvn2aNGmSTjnlFJWWluqaa65RbW1tsrIEIFGc+NtAAGwnKUHJ2rVrtWjRInXt2tXn+bvvvlsrVqzQgw8+qAULFmj79u26+uqrk5ElAInEMAyABLA8KPnpp5/0pz/9SVOmTFFhYaH7+R9//FFLlizRzTffrPLycnXv3l133323Vq9erTVr1lidLQAAYDOWByWTJ09W//791adPH5/n161bp/r6ep/nO3XqpPbt2xOUAACQgSyd6PrSSy/p008/1XPPPdfotdraWuXl5ally5Y+zxcVFWnHjh1WZgsAANiQZUHJf/7zH91111166qmn1KRJE6s+BgAApAnLgpJPPvlEdXV1Ov/8893PHTx4UKtWrdIzzzyjOXPmqL6+Xrt27fLpLamrq1Pr1q2tyhYAALApy4KS3r176+9//7vPc7fccouOOeYYjR07Vu3atVNeXp5WrlypyspKSdLXX3+trVu36sQTT7QqWwAAwKYsC0qaN2+uLl26+DzXtGlTHXrooe7nL7jgAk2bNk2FhYVq3ry5pkyZotLSUoISAAAyUEpXdL311luVnZ2ta6+9Vvv371ffvn11xx13pDJLAAAgRbIMwzBSnYlIVVRUSJKWL1+e4pwAAIBIRdp+84N8gNVi/bE6AMgw/CAfYDV+rA4AIkJQAljN/JE6fqwOAEIiKAGsZv5YHQAgJOaUAAAAWyAoAQAAtkBQAgAAbIGgBAAA2AJBCQAAsAWCEgAAYAsEJQAAwBYISgAAgC0QlAAAAFsgKAEAALZAUAIAAGyBoAQAANgCQQkAALAFghIAAGALBCUAAMAWCEoAAIAtEJQAAABbICgBAAC2QFACAABsgaAEAADYAkEJAACwBYISAABgCwQlAADAFghKAACALRCUAAAAWyAoAQAAtkBQAgAAbIGgBAAA2AJBCQAAsAWCEkCSamqkkSNdfwEAKZGb6gwAtjB9urR4sevfzzyT2rwAQIYiKAEkqbra9y8AIOkISgBJKiujhwQAUow5JQAAwBYISgAAgC0QlAAAAFsgKAEAALZAUAIAAGyBoAQAANgCQQkAID2wMrPjsU4JACA9sDKz4xGUAADSAyszOx5BCQAgPbAys+MxpwRwAsbKAWQAekoAJ2CsHEAGoKcEcILqamnYMMbKER963GBz9JQATsBYORKBHjfYHEEJAGQK7k6BzRGUAECmoMcNNsecEgAAYAsEJQAAwBYISgAAgC1YGpQ88cQTuuCCC1RaWqry8nJdddVV+vrrr33S7Nu3T5MmTdIpp5yi0tJSXXPNNaqtrbUyWwCQGNxiCySUpUHJBx98oJEjR2rx4sWaO3euDhw4oKqqKu3Zs8ed5u6779aKFSv04IMPasGCBdq+fbuuvvpqK7MFAIlh3mI7fXqqcwKkBUvvvpkzZ47P/6dNm6by8nJ98sknOumkk/Tjjz9qyZIluv/++1VeXi7JFaQMGjRIa9as0Yknnmhl9gAgPtxiCyRUUueU/Pjjj5KkwsJCSdK6detUX1+vPn36uNN06tRJ7du315o1a5KZNQCInnmLbVlZqnMCpIWkBSUNDQ26++671bNnT3Xp0kWSVFtbq7y8PLVs2dInbVFRkXbs2JGsrAEAABtI2uJpkyZN0hdffKGFCxcm6yMBAICDJKWnZPLkyXrzzTc1b948tW3b1v18q1atVF9fr127dvmkr6urU+vWrZORNQAAYBOWBiWGYWjy5Ml67bXXNG/ePHXs2NHn9e7duysvL08rV650P/f1119r69atTHIFACDDWDp8M2nSJC1dulSPPvqomjVr5p4n0qJFCxUUFKhFixa64IILNG3aNBUWFqp58+aaMmWKSktLCUoAAMgwlgYlzz77rCTpkksu8Xl+6tSpOv/88yVJt956q7Kzs3Xttddq//796tu3r+644w4rswUAAGwoyzAMI9WZiFRFRYUkafny5SnOCQAAiFSk7Te/fQMAAGyBoAQAANgCQQkAALAFghIAAGALBCUAAMAWCEoAAIAtEJQAAABbICgBAAC2QFASSE2NNHKk6y8AAEgKS5eZd6zp06XFi13/fuaZ1OYFAIAMQVASSHW1718AAGA5gpJAysroIQEAIMmYUwLrMUcHABABekpgPeboAAAiQFAC6zFHBwAQAYISWI85OgCACDCnBAAA2AJBCQAAsAWCEgAAYAsEJQCA9JEuSxCky35EiaAEADK0AUhL5hIE06enOifxSZf9iBJBCYD0Fy7osLIByOSAJxX7Xl0tDRvm/CUI0mU/osQtwQDSX7gF/KxcSyeTFw9Mxb6nyxIE6bIfUSIoAZKlpsZVSVdXuyocJE+4oMPKBiCTFw/M5H2XuOZjwPANkCzRDBGkQ5e/nfbBDDpS0TAk8rPtVKaRSGW5BxJL+cVT5hk6LyQeBCVWCnYyJ6piqamRzj7b9XBKJRWK0yrcaEUzRpwOlVk67EMyRXL+U6bxiaX84inzWOeF+J8LkZwb6VJ/Gg4yYMAAY8CAAanORuRGjDCM3FzX30iej8SqVa73rVplGJWVhiEZRlaW69/m87Hy3nYqxFMu6SbVxyIR0mEfkimS858yjU8s5ZeKMvc/FyI5N2xef0bafhOUWCnYyRzPSe594lVWugKStm1d/87JMYyiIsNo184wxo41jOJiw5g3L/J8pPqkpsJ1Jv/jxnGMDeUGUyzXlM3PH4KSdOV94vn/u7jY1XMiuQIUyfVcpD02gU5qm5/o8JKqYxXLtzoAGSXS9ps5JXYWaIzQe+KY/ySybt2kHj2kdu2kyy+Xioulyy6T6uqkiorG45r+452BJqVl6hh2LGO6qRbPsYpn//zPowxdXwFAAiQhQEqYjOspieYbp5nWf25JvN9a7dxTEmmXZmWl6xFNV6h/eVZWRlaOiSqvZI99R3qe2Pl8sBPKCfDB8E06iKZiM9P6N57pXDlGOvkrK8v1iGZ4wb88I51IHGzb0R6HRG0nUpFu1y5DM3Y/r8OVk93zbzeJLi/KP+kISjJVJl1sVvaURPMZkaSPtjGfN88zUTme7SRasHwlW6rLIZxw543d8283iS4vyj/pmFOSqSJZrMgJ8yMiEcm+lpVJL7/sesSygFOozwg358c7nfe8Hu/3BTsWr7wiffut66+3ykrpiCNcf1MhWL6Sze7zVsKdm9XVrvOhrs7512EyJPp42/38yWRJCJAShp6SIKL95l9c7Lo7J1O+JVh163Ok2zFv3W7XzpMXc0go2LFIVI9LMLHexptJPXFW49t64nj34HGO2hLDN8kQS9e+/1BCIkQ7ITYnx3UBZ8pFG8mtz7GIdDvmIneSJ31lpWt9mexsV7AS6TkR6jNDrUdTWWkYvXu7/poVuHcwRAOZfE5pPJ2QT3M5hFBLICClCEqSIdqTP9Cky0SI5luuFUGR3SWiUo1nG95BQXm5629RkasSNRe+S8QKv6HWo8nK8qz+awYk3sGQExoeJ+QxHdmlkQ9VfwXqKZk3j/MlEkm6rghKksEuPSWRCnbbcLpLxEWXiIrZOzgwH+3aBa48Y7kbJtKekokTXZ9bVOSsYTy7NI52ZGXDEu+2E5W3aL/UhTpfCHA9knRdEZSkmh1P+mC3DUf6PjvtSzQScdHFWgbe7/MODnr3dgUGwYKCSPMcy9wQ7+DIimG8VN+2nGx2aLRjHaIMlC7R5ZzIeVDRfKkLtR9WN8R2PVcDoackdo4KSmI56WOZLxDpdr0vZv//h7vN027fUMOVRayTOK3IW7hva8Eq2Wj30RTJsbK6x85u50uiRXOMI2FF0BzpNgOlS/Txs+Nwiv+XhUTny47XQKieVIKS2NgqKDEP5NixhtG0qatLPN4TPdSJbN7BUVkZfV4DdXt6f5Y5Saxt28hO2nCVTKwNajT7E2phsXA9QYGCsFgvWP+yMH8Y0eyBCBdohroTKlSe/N8XScWfrODM7j0l8TaSkfZKRBr8Bas34smnHXpKEh28WcWKfNmxpyTYfjJ8EztbBSUjRrgaBbMbvGnTyL+lBvsWH6oSM4OS3r3Dn+z+ldm8eY23O3GiK89jx7omX7Ztaxg9eoQPfLwbxOLi2E5y79cjDQYiCfjM7QabM2MGI61aeYYuwuXZPM7BhjnM97Vt6zk+3gFDqAanuNj1nqZNA/dSBfts824e8xbjVas8E2d79w5c5qH20UqRNqzRHN9gwWi4uTn+QWuw8zdc/iJdQG7ECM/coXBfJgIF1Ob+eucz1sYukd+SA9VTgbbj/UUqlt65YO8JdLyj2Q//tPPmua6l3r1jCyIS3QMRb9CcrHxGiaAkVoFO2ECzuisrPQ1BVpZhdO/e+CQKdFH5V6zh/u+fr0jmg3hXZsEaVLN3pGlTz/a8Gzv/QMbcl3btXLexmmUSqBEIVpGYz3u/L1DD6x34+P/2TKhJuoGCMe+05j4XFnp6tyLJd6ggw3xPjx6ubZeXe84Zc0Kp2Sh5H1tzv5s2Dd1TUlzsKW8zX2Zl36mTYRQUuPbHe+Ksf3mYeTXnsQRqTK2qmAI1rKHSeTfG/mmDrUXhX5bmMTEf/ts1j0Ww8yRUA+sfdIYyb57r+AQKSvz3xTxPzC8d3tef//USKEAJ1+PhHyD4l515F1gkx3/ECN+eVzP//l9ovD/TzLdZfuZ+B9pHM+9m0O4/sTXQtWM+5397fSTBkln2sd4VGW0PRKgvXN7viyRoTlJAkQgEJbHyrrh69/b0hGRne+5WMCulvDxPIxfqG625PsW8ea6L32y4Kis9t4iaF8jEia6KrEePwBXTxImeXg3z+d69XXkoLHQFR+Y2y8s9gZN3ZbFqlad3ZOxYTwPau7dh5Oe70nsHXOZFb5ZFuKDFbBi8G0Hvb40FBa7PM8vEv9H3boi9gxHv7ZuV28SJntcmTnTlOz/flVezQSgocH2O2TvUqZPr+SZNPJVjebnr/9nZrnIsKDCM885zbc8sV+9zwv9WXvNYFxS40piVirnP+fmu7fkP9U2cGPpWRu8Kv7zc9Tndu7ueM88/c/tFRb7H07sce/f2/dbuPeHW/Hewu4G8gyzzmJrHL1jF6r0v3bu78mee04EC9969XelatXL9NfPmfW14N2zejb13w2KWv9mYeQcnwYIQ70Zq3jzXMcrO9m0Mystd22/VKnig73/8zPMsN9dznprHzvuWcO/zxLxOzTwVFXnObf/z3dxPs9H3z5d3o2geXzPoMZ+fONG1r971VKh9Ms9Js/4w64FAPUITJ7qOe2Gh53wxA+j8fM8+ml+O/NfNCRRkmNs1e6m9h0nNcgz3O1dmWfTo4Vv2bduGDmaCibYHwj+wjGQoNpJt2RxBSbTmzXNVAE2a+N6yGeiRkxP6tZwcw2je3DAOOcQT0DRrFvw9ubmedOE+2//h3TCFS5eTE9tntG7tWy7Nmze+tdX70by5b76aNPFUUIHSe28rVNnGkvdkPbKyGucv1L40a2YYPXv6lnEi8hAuTU5O8OMQKI/t2nmOfbDt5+YGf+2QQ3zff8QRnv0NVT7+eTSDkGD77J0+O9vzWd6NtxkQmNdlYaHruvfuafJ+dOrkari8z+WsLNdn5eS4ttOsmev9nTpFd342aeJqBA891FOGZr4OOcRTJ3jvk7mf/td88+a+56AZOHbv7nqYr5vl7v1//+PYo4frYX5hMcvdLF9zyNAMRLyHsHNzXdsuKjKM/v0bbz8vz7eMsrNd6fPzG/e+hhq68O7lDddLG6qnpG1bV/6Lilz7dd55rv01g2Lv4fJQAUK0vRWBeqrC3QUXaa+LjRGURMu/EuCR2EckwR4PHlLwIMH/ES4IyM52VfgFBZ5gwj9NJIGcVQ+zdyeRj+Ji3+02bRr7toIFjUVFnp6eRDy8ezwi+eYf749C+vdEmD2e3vtr7l9Rkes17+Ep76G8ykpPcGPmOZr8RRpUOCj4CIagJFqpqpic9sjO9ny7C5euU6fIe3J4pO54pjoP/o/KSs9k5GCPvDxPN77/8+a/O3XyHcLq3t03bbCAJDvbmi8pZk+IFLznJ9TDe1XeQNdV69auRst74ubEiZEHeZJnmM2/pyRQXvx7p8KVaV6eJy9m77E5DB1rr0MimJ9p7m+gnhLvoTIzKDEDFe+gyjB8l7yHG0FJtLy70iXDOOwwV5QcqvIwK0T/C/GII1wnrP82vR+FhZ7uwk6dPN2sgb6dFBS4tpmf79m2d/eod9e/mZdmzXzzbgYSobrMvfPWu7erwjDzZHZ1+8+5MeeymF3CzZsHnkfStq1njD1YpRVrA2l213tXdD16uI5fp06eXpq8vOCVZl5edAFUoJ6fQw7xzEcxy9r785s0cf3fv5EoKPBU8N5L0BcWeo6tOSzYrJmnrPPzPWXqXeF7nwsdOni27X0+mGXt/Y03P98z96agwDPkaM4BMif0muUa6TBQNI+CAt85SuZ8FLNsevTw5MfkP0Hbey5ToInJ3ivbFha6zudOnTxzdrwnBhcVuZ73DsSbNXM1YGaPgTmXybsMzW/L3kMC3vOwvOcmme8/5BDfOWzmte0dJHh/Aw82OTsQM633HLb+/V2f17+/7xwR//eVlzees2bOvzH3u3v3xhN0EzHUkSqh8u3d0xKo/OPtyUlTBCWJ4n0xV1Z6oulAk/aCvT/cZKVQ7wk1s9t/PYxAd2r4b9N7wqM5iS6aCiOaSV3+lab3/ysrPfn3n8zqPxvffF+gSbvRMr9FmhNX/fMb6A6AUHdaBNtv/+f8Z9SbDad5G2K488RseL0nNprl4n0ngTm52Txf/e828Z+oGqxiDbYf3vvifdeD93nofawCPczA2Gx4c3Iaf2P2/qxwY+7++bRi/N3/+PjfyRTPvAInS5f9gOUIStJFtEFAJEFFpN+urBRNsObdO5Oqrt141gzwLvNYt+PdGxDpMbeqwYjk2AUK8MLdBRPus2LJn7dE3ang3QPolC56ggekGEEJ0ocdKtR4GrRENIZ2KAOnS1QZBuopSbREH2//21A5l5BkkbbfuQLiUVMjTZ8uVVdLZWXWfEZZmfTMM9ZsO1LV1b5/k/Vekx3KwOkSVYZlZdLKlfFvJ5Tp06XFi6W6OqmoKP7ry/scNLctcU7BdghKEJ9MqeAibdACBWkEFIiWGUTU1SXm+vI+BxMRJAMWIShBfKjgfGVKkAZrmUFETY2npyTR2wZsiKAE8aGC8+XUIM27h0eyfkgOkeH6QoYhKAESyamNiHcPj2Rdb08y5iABcCxbBCXPPPOM5syZox07dqhbt24aP368SkpKUp0txIqGx3kC9fBY0dvD8BaAELJTnYFly5Zp6tSp+v3vf6/nn39e3bp1U1VVlerq6lKdtejU1EgjR7r+ZpJA+202PNOnpy5fiI7Zw1NW5vvvRKuuloYNc97wFoCkSHlQMnfuXA0bNkwXXHCBOnfurEmTJqmgoEBLlixJddaiE6ohDhWwOD2YCbTfNDwIxsqAx+T0awrIYCkdvtm/f78++eQT/fa3v3U/l52drT59+mj16tUpzFkMQk1w9O6yNtcJMIc2nN6dHWi/nTqvAulh+nTp//0/6Z13pOeeYwgRcJCUBiX//e9/dfDgQRUVFfk8X1RUpK+//jpFuYpRqIY41MJFTr1bw0QAknrM4fFVXe0KSLZscZUL5yfgGLaY6Jr2Qi1cRKOOeDm9ty3RyspcPSTetzgDcISUBiWHHXaYcnJyGk1qraurU6tWrVKUK4sRhCDRnN7bZgWuM8CRUjrRNT8/X8cff7xWev2ORENDg1auXKnS0tIU5gxwkGRMHgWAJEj58M1ll12mm266Sd27d1dJSYnmzZunvXv36vzzz0911gAAQBKl/JbgQYMG6aabbtJDDz2kc889V+vXr9fs2bPTc/iGWxUTi/IEgLSS8p4SSRo1apRGjRqV6mxYjwmJiUV5AonFnVxIMVsEJRnDKRMSnVIxOaU8Aacg0EeKpXz4JqM4ZUJiPMvEJ3NIxSnliegxNJcarMaMFKOnBI3F0wPBNy0kAudRanArNVKMoASNxVMxMaSCROA8AjISwzeZLFgXeTxd58keUqGbPz0xNAdkJIKSTBZs7oj5g2YXXmj/xj6e+S8AAFshKMlkwSa1VVdLHTp4ftAsmaLt+WBiHgCkDYKSTBasi9z8QbPhw8M39okePom254NufgBIG0x0RWCRTnZN9F0SyZ7g6JQ1WQAgA9BTEq9Mn2iZqOETsxwlT3CTjHJlToqvTD+fAaQUPSVefvop+Gs5OVJBQYC09z0qLVkqHWgiPfWUJCk7WzrkkMi26592zx7JMAKnzcqSmjaNLe3evVJDQ/B8NGsWW9qfu5fp4JP/F0QE2E+ftD9LBw8G2eh9j6rpksXKkqRnntG++2fqwHNLpW27paIi6eqrpZ493cmbNnXtoyTt2ycdOBA8v4cc4ipnSdq/X6qv93px3B9dx27c1dJPYdL6KShwnRfRpq2vd6UPpkkTKTc3+rQHDrjKIpj8fCkvL0za/zuf8xtylPfsfEmuY/bzz8G3m5fn2na0aRsaXOdaItLm5rrKQnJdE3v2JCZt0Os+zrQZVUeEuu6jTBvNdZ+wOiKOtE6uI1LGcJABAwYYAwYMsGz7rss38GPQIN+0TZsGT9u/v2/aVq2Cpy0r801bXBw87XHH+aY97rjgaYuLfdOWlQVP26qVb9r+/YOnbdrUN+2gQaHLzduFF4ZOu3vYZYaxapVhGIZx6Tk7Qqbdvt2z3auuCr3djRs9aW+4IXTades8ae+4I3TaDz7wpL333tBpV6zwpH344dBply71pJ07N3TaxYs9aRcvDp127lxP2qVLQ6d9+E+b3GlXrAid9t57Pdv94IPQae+4w5N23brQaW+4wZN248bQaa+6ypN2+/bQaS+91JN29+7QaS+80PARKi11hOthaR2x25P20ktDp6WOcD1irSMSLdL2m+Eb2MdTT3nmdaTjr0Q7SXFxdOnNYZ9PP7UmPwAyQpZhGEaqMxGpiooKSdLy5cst2b6tumY//FB6+GGfYQtHdM2ee660fLlUUSH97W/xd80GKIegaYOga9YlouGbAGkjGpK5bKS0eLEOXjhcP89+OnRahm8YvokxLXWEixOHbyJtv5lT4sX74khVWnclcVpP6bSnIksbAe9KLZFpvSthSVLuPilrj+tvszBpvfndBdOkyf81HI//j/TXxa7tBbm7x502kPnzpQkTpMmTpdGjlZ/vaejCsSptXl7kF340aXNzPZVPItPm5ERwDv/fROec6usjPt+zsyO/NqJJm5VlTVrJHmmjue5tWUckKG3C6gg/1BGpZfPswXGmTHFNTI32bpxgtxbHe4vwhAnS5s2uv6NHx7YNhMcPuTlDOt4Cz+8kpRWCEiRWrI1TsIol3sZu8mRPTwmQ6dLx15cJiNMKQQnswaqKZfRoekgAUyp6FdKxdwaWISgBgEyRil6FdOydgWUISgAA1mHOB6LAOiUArMXS9ZmNH81EFOgpAWAtuu8BRIigBIC16L4HECGGb+BMNTXS2We7HgwL2Bvd9wAiRFACZ5o+XXr1Vddj+nTP88xfyAzmcZ4/n+MNpBGGb+BM1dVSXZ3n3ybmL2QG8zi/84707beu5zjegOMRlMCZysqkl19u/DzzFzKDeXwrK6VXXuF4A5FwwEJ2BCVILyw5nR7CVZ7ex5kVe4HIOKAnmTklAOzHrDy95wshPTEPLHmqq6Vhw2zds0hQAkQrUyrRcPvp/Xqiy8QBlWfSpet5Fy4AdeJ+JyrPid53B9wJx/ANMkMix1Jj7QJ1wHiuj3D76f26lNhuYYbhGnNA13tMws0Ds3q/rbgu48mzd37S9ZiHYjjIgAEDjAEDBqQ6G0imVasMY8QI1994jBhhGLm5rr/JzJN32kTmIdb8JHK73q9blQd42KGMU5GHaM7DWFhxXfrnKZp98M6PHY55gkTafhOUIDKpqoyKiw0jJyf+CiNVF7fVFUwiywiZxTwf582L/Ly0KrCOR7x5SkbdEC6PaRqIeCMoQXCxnPTxXPixXmQjRrga2+Ji516gVlcw6VBGSA3zmi4ujvzatmODacc8+bO6t8cBCEoQXKAAY9Uqw6isdD28u+PNb1ETJ7oqr3nzEvN5kciACzVulFFy2am8Q/V0BMpnsCEF7/fbaf+QVghK0lEs3a2B3hfo/SNGGEZWlusxYkTjb1GRfJsKVqFR0cGuoj03EzlUkKi5EIGuzUD5jCTvdhyeQVqItP3m7hsniXVp7Uje579s+6efutKfdZbr92Uuu0zasCH0LZrBZoqbd1KYt7el4u4Tp935guSI9u6GSFYMDnWuJfKOJTMPXbpIc+e6VrcNlc9I8s6KyEi1JARICUNPSYJ6SsJ18xqGNePNVt0BE8k3zmg+238oC+krXO9etNeaYYQ+16I5byPtSaF3Aw7A8A0iE6xCi6dSDibSCjnaICOSSjmarnL/oax0N29e7POFrJLqIT//oLyyMvL8RBLUJjKQTnVZRcIJeQwnHfYhhQhKEBk73CobzWumWMfmI0mbaT0lxcWGIbn+RsqKoNVbJJOxrRBsgnfv3tH1RoS7xTPRgbTdpUNvTjrsQwoRlMDe4u0piZVTKxYryySWnpJYhveiESgASUYPlv/5Yf4/mp4S//xXVgYOsNIl4IhEOuyvE/fBRnkmKAECsdFFGlSgXohQw2yVla5v8sns2QnXU5KI+RL++5zMnhL/22Zj+bxYAxogUWz0JYygBIhEPI2OVQGOdy+EuTBasMbf7D2QrJ8DE+28nEhXsEzE58XKys9wQgCM9Gajc5CgBDCFujArK12NeWVl8LTh7lCyYujC7IUIt4R8vD0liQw0/PMU70TPaMS6PRt9kwTSGeuUACZzbYi6OqmoyLN+RE2NtHatJ11NjTRkiPSf/0grVkgvvuhKF2wtC6vWdPD+hdzjjvOseREs7csvx/5Z0azTEen+Tp8uLV8uVVQEX68j0b8CHMuvqdbUuM6JigrW5QBsgqAE6c9scOrqfBuu6dOl7dulI4+UpkyRbr/dFZBIrr+33+5q8IM1xoluWAOx+jPCBRr+C4FFs8CYf3lbKZYA0Qyehg1jQT3AJghKkD6CraTpvaKs2VMi+f4102dlSbm50oEDjd+fjkKttltTI114obRli+v/kZZBsPK2UizHiNVLkQze9ZLEytJhEJQgfYTrwvdvuPz/P2WKqxGtrJReeSV9GyuzkvTez0BlN326KyDp0CG2srB7MJeM/KXTzxuk074kUyJ/WiADEJQgfcT7zde7kRo9OjF5sqNAv4UU6rdSunRx9ZhMnuw7xyVRDVM6N3axzHWxWqzlbcd9cYJQ1xYaIShB+rD7N3O7MCtE756SQGVnPnfUUdLmzdKECdKppya+YUrnxq6y0hX8demSuh+j9BdreTPcFRv/ayvdzvEEy051BgAkmVlJjh7t+huukZw8WSoudv2trnZNDE1kw2TFNiXPPJmamtRt45VXXL1Rc+e6AoHp02PPS6LEUt41Na6J3+YviQdLE295J5od84TQknB7csKwTgmAiCViDZJ4t2H1bwT5f06s2w/3/kiW+Lfjmi+JOn7JWm8njbFOCYDM5j/cEMtcCqfMU4p3CCzc+6urPb0kwcrTu6zMnhXJNYE82iGrRM0zivf4hSuX22+XXn3VVTbxrBcEN4ISAPYXrJEK1Xj5j+XH0nA7ZZ5SvI1vuPcHWqTPvzy9y2rkSFdjLbnuaIu2DBM1zyje48c8mqQjKAFgL4ECjWCNlBUr0jpRvI1vPOu8VFY2nsQbqGcllm1HuqhfpK9FK1y5mMsIpOM5lSIEJQDsJVCgEayRiibQcEqvh1OYQzaBFtiL9+cPAh0r72AjVDBq5d1c/gEP51TCWRKUbNmyRY8++qjee+891dbWqk2bNhoyZIjGjRun/Px8d7rPPvtMkydP1scff6zDDz9co0aN0tixY63IEgCnCBRoBKv8ndwoxDIkZTfxLrAX7WeZwUaoYNTKHrF0vn3dJiwJSr7++msZhqHJkyeruLhYGzZs0Pjx47V3717ddNNNkqTdu3erqqpK5eXlmjRpkjZs2KBbb71VLVu21PDhw63IFgAncHKgEY1EDEmlWqCfakjWZwUrGyvPn3QeArQJS4KSfv36qV+/fu7/d+zYURs3btSzzz7rDkpefPFF1dfX6+6771Z+fr5++ctfav369Zo7dy5BCYD0l4ghqVRLZgBph2DVDnlIc0lbPO3HH39UYWGh+/9r1qxRWVmZz3BO3759tXHjRv3www/JyhYApIbZwAW7a8juQzeABZISlGzevFlPP/20LrroIvdztbW1atWqlU868/+1tbXJyBYAALCRqIZv7r//fs2aNStkmmXLlqlTp07u/2/btk1XXHGFzj77bA0bNiy2XAIAgLQXVVBy+eWXa+jQoSHTdOzY0f3vbdu2afTo0SotLdWdd97pk65Vq1aNekTM//v3oAAAgPQXVVBy+OGH6/DDD48orRmQHH/88Zo6daqys31Hik488UQ9+OCDqq+vV15eniTp3Xff1dFHH+0z9wQAAGQGS+aUbNu2TZdcconatWunm266STt37tSOHTu0Y8cOd5rBgwcrLy9Pt912m7744gstW7ZM8+fP12WXXWZFlgAAgM1ZckvwO++8o82bN2vz5s0+twZL0ueffy5JatGihebMmaPJkyfr/PPP12GHHaarrrqK24EBAMhQWYZhGKnORKQqKiokScuXL09xTgAAQKQibb+Ttk4JAABAKAQlAADAFghKAACALRCUAAAAWyAoAQAAtkBQAgAAbMGSdUqssn37dh08eNB9axEAALC///znP8rJyQmbzlE9JU2aNFFurqPiKAAAMl5ubq6aNGkSNp2jFk8DAADpy1E9JQAAIH0RlAAAAFsgKAEAALZAUAIAAGyBoAQAANhCRgUlu3fv1l133aUzzjhDJSUluuiii7R27Vr364ZhaMaMGerbt69KSko0ZswYbdq0KXUZdrBQZV1fX6/77rtPgwcP1oknnqi+ffvqxhtv1LZt21Kca+cJd057mzBhgrp27ao///nPyc1kGoiknL/66iuNGzdOvXr10oknnqgLLrhAW7duTVGOnStcWf/000+aPHmy+vXrp5KSEg0aNEjPPvtsCnNsf6tWrdK4cePUt29fde3aVa+//rrP65G0fd9//73++Mc/qmfPniorK9Ott96qn376KfGZNTLIddddZwwaNMj44IMPjE2bNhkPPfSQ0bNnT+O7774zDMMwnnjiCaNXr17Ga6+9Zqxfv94YN26cMWDAAOPnn39Occ6dJ1RZ79q1yxgzZozx0ksvGV999ZWxevVq48ILLzSGDh2a6mw7Trhz2vTqq68aQ4YMMfr27WvMnTs3NZl1sHDlvHnzZuPkk0827rnnHuOTTz4xNm/ebLz++utGbW1tinPuPOHK+vbbbzcGDhxovPfee8Y333xjLFq0yDj22GON119/PcU5t68333zTeOCBB4xXX33V6NKli/Haa6/5vB5J21dVVWUMGTLEWLNmjbFq1SrjzDPPNP7whz8kPK8ZE5Ts3bvXOPbYY40VK1b4PD906FDjgQceMBoaGoxTTz3VmD17tvu1Xbt2Gd27dzeWLl2a5Nw6W7iyDuSjjz4yunTpYnz77bdJyGF6iLScv/vuO+O0004zNmzYYJxxxhkEJVGKpJyvv/5644YbbkhB7tJLJGV9zjnnGA8//HDQ1xGaf1ASSdv35ZdfGl26dDHWrl3rTvPPf/7T6Nq1a6MvQPHKmOGbAwcO6ODBg41WlGvSpIk+/PBDbdmyRTt27FCfPn3cr7Vo0UInnHCCVq9enezsOlq4sg5k9+7dysrKUsuWLZORxbQQSTk3NDToT3/6k6qqqvTLX/4yFdl0vHDl3NDQoDfffFNHHXWUqqqqVF5ert/85jeNusgRXiTndGlpqd544w1t27ZNhmHovffe08aNG9W3b99UZNnxImn7Vq9erZYtW6pHjx7uNH369FF2dnbQ4eJYZUxQ0rx5c5WWlurRRx/Vtm3bdPDgQf3tb3/TmjVrtH37du3YsUOSVFRU5PO+oqIi1dbWpiLLjhWurP3t27dP999/v8455xw1b948BTl2pkjKedasWcrNzdXo0aNTnFvnClfOdXV12rNnj2bNmqXTTjtNTz31lM4880xdffXV+uCDD1KdfUeJ5JweP368OnfurH79+ql79+664oordMcdd+ikk05Kce6dKZK2r7a2VocffrjP67m5uSosLHS/P1EyJiiRpHvvvVeGYahfv37q0aOHFixYoHPOOUfZ2RlVDEkRaVnX19fruuuuk2EYmjRpUopy61yhynndunWaP3++pk6dqqysrFRn1dFClXNDQ4MkqaKiQmPGjNGxxx6rK6+8UqeffroWLVqU4pw7T7i6Y8GCBVqzZo0ee+wxLVmyRDfffLMmTZqkd999N8U5RyJk1K/bHXnkkXr66ae1Z88e7d69W23atNH111+vjh07qnXr1pKkuro6tWnTxv2euro6devWLVVZdqxQZW2qr6/X9ddfr61bt2revHn0ksQgVDnX1NSorq5OZ5xxhjv9wYMHdc8992j+/Pl64403UphzZwlVzocddphyc3PVqVMnn/d06tRJ//rXv1KUY+cKVdY///yzpk+frocfflinn366JKlbt25av3695syZ4zMEgchE0va1atVKO3fu9HnfgQMH9MMPP7jfnygZ2UXQtGlTtWnTRj/88IPefvttVVRUqEOHDmrdurVWrlzpTrd792599NFHKi0tTWFunS1QWUuegGTz5s3685//rMMOOyzFOXW2QOV87rnn6sUXX9QLL7zgfrRp00ZVVVWaPXt2qrPsSIHKOT8/Xz169NDGjRt90m7atElHHHFEinLqfIHK+sCBA6qvr2/U85eTkyOD35aNSSRtX2lpqXbt2qV169a507z33ntqaGhQSUlJQvOTUT0lb731lgzD0NFHH61///vfuvfee3XMMcfo/PPPV1ZWlkaPHq3HHntMxcXF6tChg2bMmKE2bdpo4MCBqc6644Qq6/r6el177bX69NNP9cQTT+jgwYPuccnCwkLl5+enOPfOEaqc8/LyGgV7eXl5atWqlY455pgU5diZQpWzJFVVVam6ulonnXSSTjnlFL311ltasWKF5s+fn+KcO0+4c/rkk0/Wfffdp4KCArVv316rVq3SCy+8oJtvvjnVWbetn376Sf/+97/d/9+yZYvWr1+vwsJCtW/fPmzb16lTJ5122mkaP368Jk2apPr6et15550655xz9Itf/CKhec0yMii8XLZsmR544AF99913OvTQQ3XWWWepurpaLVq0kORaQOahhx7S4sWLtWvXLvXq1Ut33HGHjj766BTn3HlClfWWLVvcPSb+5s+fr1NOOSXJuXWucOe0vwEDBmj06NEaM2ZMcjPqcJGU83PPPacnn3xS3333nY4++mhdc801fKGJQbiy3rFjhx544AG9/fbb+uGHH9S+fXsNHz5cY8aMYe5UEO+//37Aye5Dhw7VtGnTImr7vv/+e91555164403lJ2drbPOOku33367mjVrltC8ZlRQAgAA7Csj55QAAAD7ISgBAAC2QFACAABsgaAEAADYAkEJAACwBYISAABgCwQlAADAFghKAACALRCUAAAAWyAoAQAAtkBQAgAAbOH/A01C5854teIRAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    feat = feat_mean - 1 * feat_std\n",
    "    feat_inv = feat[unq_inv]\n",
    "    mask = org_xyz[:, 1] < feat_inv\n",
    "\n",
    "rand_x, rand_y = np.random.randint(0, voxel_dim[0]), np.random.randint(0, voxel_dim[1])\n",
    "vox_mask = (voxel_index[:, 0] == rand_x) & (voxel_index[:, 1] == rand_y)\n",
    "\n",
    "if vox_mask.sum() == 0:\n",
    "    print(f\"No points in voxel ({rand_x}, {rand_y})\")\n",
    "else:\n",
    "    z_max = feat[unq_inv[vox_mask][0]]\n",
    "\n",
    "    plt.figure()\n",
    "    plt.style.use('seaborn-white')\n",
    "    # plt.axis('equal')\n",
    "    # plt.scatter(org_xyz[::500, 0], org_xyz[::500, 2], c='dimgrey', s=0.5)\n",
    "    plt.scatter(org_xyz[vox_mask, 0], org_xyz[vox_mask, 1], c='r', s=0.5)\n",
    "    plt.plot([org_xyz[vox_mask, 0].min(), org_xyz[vox_mask, 0].max()], [z_max, z_max], 'b--')\n",
    "    plt.title(f'Voxel Index: ({rand_x}, {rand_y})')\n",
    "    # plt.xlim(-200, 150)\n",
    "    # plt.ylim(-200, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-250.0, 125.0)"
      ]
     },
     "execution_count": 308,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xyz = gaussians.get_xyz.cpu().detach().numpy()\n",
    "rot_xz_angle = -37 * np.pi / 180  # 21 for residence, -37 for sci-art\n",
    "rot_mat = np.array([[np.cos(rot_xz_angle), 0, np.sin(rot_xz_angle)], [0, 1, 0], [-np.sin(rot_xz_angle), 0, np.cos(rot_xz_angle)]])\n",
    "xyz = np.dot(xyz, rot_mat.T)\n",
    "plt.figure()\n",
    "plt.style.use('seaborn-white')\n",
    "# plt.axis('equal')\n",
    "plt.scatter(xyz[::100, 0], xyz[::100, 2], c='dimgrey', s=0.5)\n",
    "plt.plot([117, 117], [-250, 125], 'r--')\n",
    "plt.xlim(-150, 200)\n",
    "plt.ylim(-250, 125)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    # mask = (xyz[:, 1] < 20)  # rubble\n",
    "    # mask = (xyz[:, 1] < 35) & (xyz[:, 0] < -15)  # building\n",
    "    mask = (xyz[:, 1] < 30) & ((xyz[:, 0] > -150) & (xyz[:, 0] < 200) & (xyz[:, 2] > -250) & (xyz[:, 2] < 125)) \\\n",
    "           & ~((xyz[:, 0] > 80) & (xyz[:, 0] < 117) & (xyz[:, 2] > -4) & (xyz[:, 2] < 37))  # sci-art\n",
    "    gaussians._scaling = org_scaling.clone()\n",
    "    gaussians._opacity = org_opacity.clone()\n",
    "    gaussians._scaling[mask] = -1e6\n",
    "    gaussians._opacity[mask] = -1e6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_center_list = []\n",
    "dim = 2\n",
    "for idx in range(len(views)):\n",
    "    Rt = np.zeros((4, 4))\n",
    "    Rt[:3, :3] = views[idx].R.transpose()\n",
    "    Rt[:3, 3] = views[idx].T\n",
    "    Rt[3, 3] = 1.0\n",
    "\n",
    "    C2W = np.linalg.inv(Rt)\n",
    "    cam_center_list.append(C2W[:3, -1])\n",
    "cam_center_array = np.array(cam_center_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cam_centers = np.array(cam_center_list)\n",
    "pose1_center = cam_centers[np.where(cam_centers[:, 2] == cam_centers[:, 2].max())]\n",
    "pose2_center = cam_centers[np.where(cam_centers[:, 0] == cam_centers[:, 0].max())]\n",
    "pose3_center = cam_centers[np.where(cam_centers[:, 2] == cam_centers[:, 2].min())]\n",
    "pose4_center = cam_centers[np.where(cam_centers[:, 0] == cam_centers[:, 0].min())]\n",
    "\n",
    "scale_factor = 0.8\n",
    "region_center = (pose1_center[0] + pose2_center[0] + pose3_center[0] + pose4_center[0]) / 4\n",
    "pose1_center = region_center + scale_factor * (pose1_center[0] - region_center)\n",
    "pose2_center = region_center + scale_factor * (pose2_center[0] - region_center)\n",
    "pose3_center = region_center + scale_factor * (pose3_center[0] - region_center)\n",
    "pose4_center = region_center + scale_factor * (pose4_center[0] - region_center)\n",
    "\n",
    "\n",
    "# pose1_center[0] -= 90  # for building\n",
    "# pose1_center[2] -= 75  # for building\n",
    "# pose2_center[0] -= 125  # for building\n",
    "# pose2_center[2] -= 25  # for building\n",
    "# pose3_center[2] += 25  # for building\n",
    "# pose4_center[0] += 25  # for building\n",
    "# pose4_center[2] -= 25  # for building\n",
    "\n",
    "# pose1_center[0] += 50  # for residence\n",
    "# pose2_center[0] += 50  # for residence\n",
    "# pose3_center[2] += 50  # for residence\n",
    "\n",
    "# pose2_center[0] += 20\n",
    "pose2_center[2] += 25\n",
    "pose3_center[2] += 25\n",
    "pose4_center[0] -= 10\n",
    "\n",
    "pose1 = views[np.where(cam_centers[:, 2] == cam_centers[:, 2].max())[0].item()]\n",
    "pose2 = views[np.where(cam_centers[:, 0] == cam_centers[:, 0].max())[0].item()]\n",
    "pose3 = views[np.where(cam_centers[:, 2] == cam_centers[:, 2].min())[0].item()]\n",
    "pose4 = views[np.where(cam_centers[:, 0] == cam_centers[:, 0].min())[0].item()]\n",
    "\n",
    "poses = [pose1, pose2, pose3, pose4, pose1, pose2]\n",
    "# pose_centers = [pose1_center, pose2_center, pose3_center, pose4_center]  # for building\n",
    "pose_centers = [pose1_center, pose2_center, pose3_center, pose4_center, pose1_center]\n",
    "\n",
    "plt.scatter(cam_center_array[:, 0], cam_center_array[:, dim], s=100, c='r', marker='x')\n",
    "plt.scatter(np.array(pose_centers)[:4, 0], np.array(pose_centers)[:4, dim], s=100, c='b', marker='x')\n",
    "for idx in range(len(poses[:4])):\n",
    "    plt.text(pose_centers[idx][0], pose_centers[idx][dim], f'{idx+1}', fontsize=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.5, 1215.5, 911.5, -0.5)"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "video_path = os.path.join(lp.model_path, filename, \"ours_lod_video\")\n",
    "makedirs(video_path, exist_ok=True)\n",
    "frames = []\n",
    "pose_per_segment = 300\n",
    "\n",
    "# second parameter appoints number of points interpolated between each consecutive points to draw the curve\n",
    "interp_xyz, _ = evaluate_bezier_v3(pose_centers, pose_per_segment)\n",
    "xyz_pre = None\n",
    "\n",
    "fontsize = 20\n",
    "fig = plt.Figure(figsize=(16, 12), dpi=76)\n",
    "fig.set_tight_layout(True)\n",
    "canvas = FigureCanvasAgg(fig)\n",
    "ax = fig.gca()\n",
    "gs_xyz = gaussians.get_xyz.cpu().detach().numpy()\n",
    "ax.scatter(gs_xyz[::200, 0], gs_xyz[::200, dim], c='dimgrey', s=0.5)\n",
    "# ax.plot(cam_center_array[simplified_hull,0], cam_center_array[simplified_hull, dim], 'r--^',lw=2)\n",
    "ax.axis('equal')\n",
    "ax.set_xlabel('x/m', fontsize=fontsize)\n",
    "ax.set_ylabel('y/m', fontsize=fontsize)\n",
    "ax.tick_params(axis='both', which='major', labelsize=fontsize)\n",
    "ax.set_xlim(np.min(cam_center_array[:, 0]), np.max(cam_center_array[:, 0]))\n",
    "ax.set_ylim(np.min(cam_center_array[:, dim]), np.max(cam_center_array[:, dim]))\n",
    "\n",
    "plt.style.use('seaborn-white')\n",
    "for t in range(len(interp_xyz)):\n",
    "    xyz = interp_xyz[t]\n",
    "    xyz[1] = pose2_center[1] + 35\n",
    "\n",
    "    if t == 0:\n",
    "        delta = interp_xyz[t + 1] - interp_xyz[t]\n",
    "    else:\n",
    "        delta = xyz - xyz_pre\n",
    "    \n",
    "    if not np.any(delta):\n",
    "        continue\n",
    "    \n",
    "    ax.scatter(xyz[0], xyz[dim], s=100, c='r', marker='x', label='poses')\n",
    "    if t == 0:\n",
    "        ax.legend(fontsize=fontsize)\n",
    "    # canvas.draw()\n",
    "    # buf = canvas.buffer_rgba()\n",
    "    # bev_map = np.asarray(buf)[..., :3]\n",
    "\n",
    "    angle = np.arctan2(delta[dim], delta[0])\n",
    "    # angle = np.arctan2(delta[0], -delta[dim])  # for building\n",
    "\n",
    "    viewpoint_cam = loadCamV3(lp, idx, poses[0], 1.0, xyz=xyz, z_dim=1, yaw=angle)\n",
    "    img = render(viewpoint_cam, gaussians, pp, background)[\"render\"]\n",
    "    img = (img * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).cpu().numpy()\n",
    "\n",
    "    # img = np.concatenate([img, bev_map], axis=1)\n",
    "    \n",
    "    frames.append(img)\n",
    "\n",
    "    xyz_pre = xyz\n",
    "\n",
    "canvas.draw()\n",
    "buf = canvas.buffer_rgba()\n",
    "bev_map = np.asarray(buf)[..., :3]\n",
    "plt.imshow(bev_map)\n",
    "plt.axis('off')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Video saved to ../output/block_sciart_all_lr_c9_loss_5_r4/train/ours_lod_video\n"
     ]
    }
   ],
   "source": [
    "video = imageio.get_writer(os.path.join(video_path, \"video.mp4\"), mode=\"I\", fps=30, codec=\"libx264\", bitrate=\"16M\", quality=10)\n",
    "for frame in frames:\n",
    "    video.append_data(frame)\n",
    "video.close()\n",
    "print(f'Video saved to {video_path}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Zoom Out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "video_path = os.path.join(model_path, config_name, \"ours_lod_video\")\n",
    "makedirs(video_path, exist_ok=True)\n",
    "\n",
    "idx = 481\n",
    "pitch = -180.0\n",
    "duration_list = []\n",
    "frames = []\n",
    "\n",
    "for height in tqdm(range(500, 2500, 15)):\n",
    "\n",
    "    viewpoint_cam = loadCamV2(lp, idx, views[idx], 1.0, pitch, float(2500)/100)\n",
    "\n",
    "    start = time.time()\n",
    "    img = render_lod(viewpoint_cam, lod_gs_list, pp, background)[\"render\"]\n",
    "    img = (img * 255).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).cpu().numpy()\n",
    "    end = time.time()\n",
    "    frames.append(img)\n",
    "    duration_list.append(end - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (1600, 900) to (1600, 912) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to 1 (risking incompatibility).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Video saved to ../output/block_mc_aerial_block_all_lr_c36_loss_5_lod/block_mc_aerial_block_all_lr_c36_loss_5_75_lr64_vq/ours_lod_video\n"
     ]
    }
   ],
   "source": [
    "video = imageio.get_writer(os.path.join(video_path, \"video.mp4\"), mode=\"I\", fps=36, codec=\"libx264\", bitrate=\"16M\", quality=10)\n",
    "for frame in frames:\n",
    "    video.append_data(frame)\n",
    "video.close()\n",
    "print(f'Video saved to {video_path}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "gaussian_splatting",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
